Arrays vs. Pointers for Strings: Memory and Mutability

The Two Syntaxes: A Tale of Two Strings

At a glance, these two lines of code might seem to do the same thing, but their implications for memory and modification are profoundly different.

1. char arr[] = "hello"; // The array initialization syntax
2. char *p = "hello"; // The pointer initialization syntax

Let's break down each one.

Case 1: char arr[] = "hello"; — The Writable Copy

When you use this syntax, you are doing two things:

1. Declaring an array of characters named arr.
2. Initializing this array with the contents of the string literal "hello".

The C standard specifies that this initialization is essentially a shorthand for creating an array and copying the characters of the literal into it, including the null terminator.

char arr[] = {'h', 'e', 'l', 'l', 'o', '\0'};

Memory Location and Mutability

• Memory Location: If arr is a local variable, memory for the array (6 bytes in this case) is allocated on the stack. The string literal "hello" itself exists in a read-only section of memory, but its content is copied to the stack where arr resides. If arr were a global or static variable, it would be allocated in the program's read-write data segment (.data).
• Mutability: Because arr is an array that owns its own writable memory (on the stack or in .data), its contents are modifiable.

Let's see this in a code example:

#include <stdio.h>
#include <string.h>

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

    printf("Original string: %s\n", arr);
    
    // This is valid because 'arr' is a writable copy on the stack.
    arr[0] = 'j'; 
    printf("Modified string: %s\n", arr);

    // However, 'arr' itself is an array name, not a modifiable pointer.
    // arr++; // Compile-time error: expression must be a modifiable lvalue

    // sizeof confirms 'arr' is an array of 6 bytes.
    printf("sizeof(arr) = %zu\n", sizeof(arr)); // Output: 6

    return 0;
}

To reinforce this, please read the following material which lays out this behavior clearly.

Case 2: char *p = "hello"; — The Pointer to Immutable Data

This syntax is fundamentally different. You are:

1. Declaring a pointer-to-character named p.
2. Initializing this pointer to hold the memory address of the first character of the string literal "hello".

Memory Location and Mutability

• Memory Location:
  • The pointer p is a variable that is allocated on the stack (if local). It stores a memory address. Its size is the size of a pointer on your system (e.g., 8 bytes on a 64-bit architecture).
  • The string literal "hello" is stored in a read-only segment of your program's memory (often called .rodata).
• Mutability: This is the critical difference. Since p points to a location in read-only memory, attempting to modify the string through the pointer is undefined behavior (UB). On most modern systems, this will result in a segmentation fault at runtime.
  • The data it points to is immutable.
  • The pointer p itself is mutable. You can change p to point to a different address.

The following reading from a highly-voted Stack Overflow answer uses compiler output to prove that the string literal is placed in a read-only section. This level of detail is exactly what interviewers look for from experienced candidates.

const Correctness: A Best Practice

Because modifying a string literal via a char * is undefined behavior, it's a best practice to declare the pointer as const char *.

const char *p = "hello";

This makes your intention clear and allows the compiler to help you. If you accidentally try to modify the string, you will get a compile-time error instead of a runtime crash, which is always preferable.

const char *p = "hello";
// p[0] = 'j'; // Now this is a compile-time error!

Synthesizing the Differences

Here is a summary table that you can use to structure your answer in an interview:

Deeper Dive: String Literal Pooling

There's one more advanced topic related to char *p = "string"; that's worth knowing: string literal pooling (or interning). Compilers are smart. If they see the same string literal multiple times in your code, they may store it only once in the .rodata section to save memory.

const char *p1 = "hello";
const char *p2 = "hello";

// p1 and p2 might point to the exact same memory address!
// if (p1 == p2) { ... } // This could be true.

The C standard allows this optimization but doesn't guarantee it. This has a critical practical implication: never use the == operator to compare the content of two strings pointed to by char* variables. You must always use strcmp.

Conclusion

You are now equipped to provide a comprehensive answer that goes beyond the surface level.

Key Takeaways:

• char arr[] = "string"; creates a mutable copy of the string on the stack (or in .data). arr is an array, not a pointer.
• char *p = "string"; creates a pointer on the stack that points to an immutable string literal in a read-only memory segment.
• Attempting to modify the data through the pointer p is undefined behavior. Using const char * is the correct and safe way to declare pointers to string literals.
• The compiler may pool identical string literals, making pointer comparison (==) unreliable for checking string equality. Always use strcmp.

In our next lesson, we will continue exploring the relationship between arrays and pointers by looking at how 1D and 2D arrays are passed to functions, further examining the mechanism of pointer decay.