Difference Between `char s[]` and `char *s` in C

By the end of this page, you will understand why char s[] = "hello"; creates an array containing a copy of the string, while char *s = "hello"; creates a pointer to a string literal. You will also learn how their memory is stored, how they behave differently when modified, and why this distinction matters in real C programs.

In C, a string literal like "hello" is an array of characters stored by the implementation, with a terminating null character \0 added automatically.

These two declarations look similar, but they create very different objects:

char s[] = "hello";
char *s = "hello";

char s[] = "hello";

This declares s as an array of 6 characters:

{'h', 'e', 'l', 'l', 'o', '\0'}

The contents of the string literal are copied into the array when s is initialized. After that, s is its own array object.

• s has storage for 6 char values.
• The array is modifiable if it is not declared const.
• sizeof(s) gives the full array size, which is .

Think of these two forms like this:

• char s[] = "hello"; means make me my own writable notepad and copy hello onto it.
• char *s = "hello"; means give me the address of a printed sign that already says hello.

With the notepad, you can erase and rewrite letters:

s[0] = 'H';

With the sign, you are only pointing at something that already exists somewhere else. Trying to rewrite the sign is not allowed safely.

Also:

• an array is the actual storage
• a pointer is only an address

That single idea explains most of the behavior difference.

Core syntax

char s[] = "hello";
char *p = "hello";

Example 1: Array initialized from a string literal

#include <stdio.h>

int main(void) {
    char s[] = "hello";

    s[0] = 'H';
    printf("%s\n", s);

    return 0;
}

Output:

Hello

Explanation:

• s is an array with its own storage.
• The characters from "hello" are copied into it.
• Changing s[0] is allowed.

Example 2: Pointer to a string literal

#include <stdio.h>

int  {
     *p = ;

    (, p);
     ;
}

Consider this code:

#include <stdio.h>

int main(void) {
    char s[] = "hello";
    char *p = "hello";

    printf("%c %c\n", s[1], p[1]);
    return 0;
}

Step-by-step

1. The compiler sees the string literal "hello".
2. That literal represents the character sequence:

'h', 'e', 'l', 'l', 'o', '\0'

1. For char s[] = "hello";

   • space for 6 characters is created for s
   • those 6 characters are copied into s

   Memory idea:

When char s[] = "hello"; is useful

Editable local strings

char filename[] = "report.txt";
filename[0] = 'R';

Use this when you want to modify the characters.

Fixed-size local buffers initialized with text

char status[] = "pending";

This is common when a program starts with default text and later updates it.

When char *s = "hello"; is useful

Referring to constant message text

char *message = "File not found";

This is useful when you only need to read or print the text.

Selecting one of several literals

char *level;
if (error) {
    level = "error";
} else {
    level = "ok";
}

The pointer can be redirected to different string literals easily.

Returning or passing read-only text

In real projects, developers usually make the distinction more explicit.

Common pattern: use const char * for literals

const char *message = "hello";

This communicates:

• the text should not be modified
• the variable is just a pointer to existing character data

Common pattern: arrays for writable buffers

char buffer[64] = "hello";

This is used when code will:

• append text
• replace characters
• tokenize the string
• pass it to functions that modify the buffer

Validation and defensive coding

When a function should only read a string:

void print_name(const char *name) {
    if (name == NULL) {
        return;
    }
    printf("%s\n", name);
}

This is a common pattern in production C code:

• const char * for read-only input

1. Trying to modify a string literal through a pointer

Broken code:

char *s = "hello";
s[0] = 'H';

Why this is wrong:

• the pointer refers to a string literal
• modifying it causes undefined behavior

Safer version:

char s[] = "hello";
s[0] = 'H';

Or if it should be read-only:

const char *s = "hello";

2. Assuming an array and a pointer are the same thing

Broken thinking:

• both work with %s
• both use []
• therefore they are identical

They are not identical:

• an array stores elements directly
• a pointer stores an address

3. Using sizeof on a pointer to get string length

Broken code:

char s[] = "hello";   // array containing a copy: {'h','e','l','l','o','\0'}
char *p = "hello";    // pointer to string literal
const char *q = "hello"; // preferred for read-only literal

• String literals are null-terminated.
• char s[] = "hello"; creates writable array storage.
• char *p = "hello"; creates a pointer to literal storage.
• Modifying a string literal is undefined behavior.
• Arrays are not assignable.
• Pointers are assignable.
• sizeof(array) gives total bytes in the array.
• sizeof(pointer) gives pointer size.
• strlen(string) gives character count before \0.

Quick rules:

• Want to edit the text? Use an array.
• Want to point at fixed text? Use const char *.
• Need a function to read a string? Usually use const char *.

Example:

char name[] = ;
name[] = ;

  *msg = ;

Is char s[] = "hello"; the same as char *s = "hello";?

No. The first creates an array containing the characters. The second creates a pointer to a string literal.

Can I modify char *s = "hello";?

You should not. Modifying the string literal through that pointer causes undefined behavior.

Why does sizeof give different results?

Because in one case s is an array, and in the other case s is a pointer. Arrays and pointers are different types.

Where is the string literal stored?

The C standard does not require a specific memory section, but implementations typically place string literals in static storage, often in read-only memory.

Does char s[] = "hello"; copy the string?

Yes. The array is initialized with the literal's characters, including the terminating \0.

Why do many examples use const char * instead of char *?

Because string literals should be treated as read-only. const char * makes that intent clear and helps prevent mistakes.

Can two pointers to the same literal share storage?

• String literals — These are the source of the difference, because one declaration copies a literal and the other points to it.
• Arrays in C — Arrays store elements directly, which explains why char s[] owns its memory.
• Pointers in C — A pointer stores an address, which explains char *s.
• Null-terminated strings — Both forms rely on C string rules using the \0 terminator.
• const in C — Important for expressing that string literals should not be modified.
• sizeof operator — Useful for understanding why arrays and pointers produce different sizes.
• Storage duration in C — Helps explain where arrays and string literals live during program execution.
• Array-to-pointer decay — Important because arrays often behave like pointers in expressions, even though they are not the same type.