Are there any internal differences between compound char arrays and string literals?

Admin 1
Viewed 70

Is there any internal differences between this:

(const char[]){'H', 'e', 'l', 'l', 'o', 0}

and

"Hello"

in C?
I have noticed that string literals declared with quotes are gotten by the strings unix command, but the others aren't. What are the internal differences that cause that?

c string
3 Answers

String literals always have static storage duration, whereas compound literals at block scope have automatic storage duration.

String literals have special status in initializers, e.g. 

char x[5] = "foo";  // ok
char y[5] = (char[]){'f','o','o','\0'};   // error

String literals do not necessarily have unique addresses, e.g. "foo" == "foo" may or may not be true, and "foo" + 1 == "oo" may or may not be true, whereas similar comparison for compound literals must be false.

user_15059390

It is probably because the strings command looks for string literals within the object file and when you declare a string with char *str="Hello", your compiler saves it as a string literal and labels it. GCC shows this memory location with the .string keyword, whereas clang uses .asciz.

On the other hand, when you declare the string as an array of chars, they are stored in the memory as consecutive bytes and are not marked with .string or '.asciz`

Take this simple function

int test() {
    (const char[]){'H', 'e', 'l', 'l', 'o', 0};
    char *str="Hello";
}

below is the code generated by GCC(without any code optimisations). clang gives a similar code but the one from GCC is simpler, so I am using it for the sake of simplicity

.LC0:
        .string "Hello"
test:
      push    rbp                                 ; function prologue
      mov     rbp, rsp                            ; function prologue
      mov     BYTE PTR [rbp-14], 72               ; ASCII H
      mov     BYTE PTR [rbp-13], 101              ; ASCII e
      mov     BYTE PTR [rbp-12], 108              ; ASCII l
      mov     BYTE PTR [rbp-11], 108              ; ASCII l
      mov     BYTE PTR [rbp-10], 111              ; ASCII o
      mov     BYTE PTR [rbp-9], 0                 ; ASCII null 
      mov     QWORD PTR [rbp-8], OFFSET FLAT:.LC0 ; string literal
      nop
      pop     rbp
      ret

After the function prologue, the bytes are moved to memory one by one but are not marked as a string. Whereas as your char *str="Hello"; is marked with a label and I assume the strings utility just searches for these literals.

user_18843510

String literals are often stored in a read-only section of memory, while compound literal char arrays are not.

For example, given this code:

char *x = (char *)(const char[]){'H', 'e', 'l', 'l', 'o', 0};
char *y = "Hello";
x[0] = 'X';
printf("x=%s\n", x);
y[0] = 'X';
printf("y=%s\n", y);

The modification to x[0] is successful and the modified string is printed, while the attempted change to y[0] results in a segfault.

user_16871190
Related