What is the difference between char s[] and char *s?

Question

In C, one can use a string literal in a declaration like this:

char s[] = "hello";

or like this:

char *s = "hello";

So what is the difference? I want to know what actually happens in terms of storage duration, both at compile and run time.

Subrogation

c-faq.com/aryptr/index.html c-faq.com/charstring/index.html – Liebman

char *s="hello", here s can point any another string at run time I mean it is not constant pointer you can assign another value at run time p = "Nishant", while s[] here s is constant pointer....it can't be reasign another string but we can assign another character value at s[index]. – Whiteheaded

@NishantYou meant ..you can assign another value at run time s = "Nishant", while s[] ... Did you? Otherwise, it is a little bit confusing in the context. – Coz

Answer 1

The difference here is that

char *s = "Hello world";

will place "Hello world" in the read-only parts of the memory, and making s a pointer to that makes any writing operation on this memory illegal.

While doing:

char s[] = "Hello world";

puts the literal string in read-only memory and copies the string to newly allocated memory on the stack. Thus making

s[0] = 'J';

legal.

Zerla

The literal string "Hello world" is in "read-only parts of the memory" in both examples. The example with the array points there, the example with the array copies the characters to the array elements. – Musgrave

pmg: In the second case the literal string does not necessarily exist in memory as a single contiguous object at all - it's just an initialiser, the compiler could quite resonably emit a series of "load immediate byte" instructions that contain the character values embedded within them. – Phytosociology

@pmg: to be fair it depends on the context. For a global variable, the compiler can just put "Hello world" directly in a writeable section loadable on startup, for an automatic variable the array does need to be reinitialized every time. – Edbert

The char array example does not necessarily place the string on the stack - if it appears at file level, it will probably be in some kind of initialised data segment instead. – Phytosociology

@caf, @Charles: The Standard (n1401.pdf) says @ 6.4.5 String literals /5 "... The multibyte character sequence is then used to initialize an array of static storage duration and length just sufficient to contain the sequence. ..." It doesn't "speak" of 'plain' character sequences, but I think the same applies. I also think an implementation can ignore this particular bit of the Standard for performance reasons :) – Musgrave

I'd like to point out that char s = "xx" doesn't have to be in read-only memory (some implementations have no MMUs, for example). The n1362 c1x draft simply states that modifying such an array causes undefined behavior. But +1 anyway, since relying on that behavior is a silly thing to do. – Graber

I get a clean compile on a file containing just char msg[] = "hello, world!"; the string ends up in the initialized data section. When declared char * const to end up in the read-only data section. gcc-4.5.3 – Cecilycecity

@Rickard: "Hello world" will store twice in Read only memory or only one times for both. and another question is memory is allocated for *p = "Hello" at compile time or run time. – Whiteheaded

The most current C99 draft is N1256. The most current C11 draft is N1570. – Zaid

@paxdiablo, So do you mean that the program may actually not get segmentation fault by writing to strings? – Drud

@Pacerier: correct. Undefined means exactly that, anything can happen. It could silently ignore what you're trying to do, it could make your computer explode in your face, it could erase your wedding photos. It could even, and this is the most insidious case, actually work. Right up to the point where you try your code elsewhere, or change the compiler, or try to build during a blue moon, at which point you'll suffer much angst. – Graber

@gcbenison, Regarding "the string ends up in the initialized data section", How did you verify that? – Drud

@Drud I have verified it in my answer. – Thorwald

Both are "legal" C programs: it's just that one is undefined behavior :-) – Thorwald

did you mean s[0] = 'H'; instead of s[0] = 'J'; – Gilges

@Gilges no the s[0] = 'J'; was what I intended to type. "Jello world" is underestimated. – Zerla

@Zerla if you are making fun, you should say "Bazinga" (TBBT) at the end of your above comment and edit your answer. :) else.. well, pardon me, I quite didn't get you, care to explain in details in the answer itself, again, by editing it? – Gilges

"makes any writing operation on this memory illegal" Illegal or undefined behaviour? My GCC compiler allows writing to the read only part of memory but the programme acts randomly. The compiler doesnt flag it as an error – Intorsion

Answer 2

First off, in function arguments, they are exactly equivalent:

void foo(char *x);
void foo(char x[]); // exactly the same in all respects

In other contexts, char * allocates a pointer, while char [] allocates an array. Where does the string go in the former case, you ask? The compiler secretly allocates a static anonymous array to hold the string literal. So:

char *x = "Foo";
// is approximately equivalent to:
static const char __secret_anonymous_array[] = "Foo";
char *x = (char *) __secret_anonymous_array;

Note that you must not ever attempt to modify the contents of this anonymous array via this pointer; the effects are undefined (often meaning a crash):

x[1] = 'O'; // BAD. DON'T DO THIS.

Using the array syntax directly allocates it into new memory. Thus modification is safe:

char x[] = "Foo";
x[1] = 'O'; // No problem.

However the array only lives as long as its contaning scope, so if you do this in a function, don't return or leak a pointer to this array - make a copy instead with strdup() or similar. If the array is allocated in global scope, of course, no problem.

Expurgatory

Answer 3

This declaration:

char s[] = "hello";

Creates one object - a char array of size 6, called s, initialised with the values 'h', 'e', 'l', 'l', 'o', '\0'. Where this array is allocated in memory, and how long it lives for, depends on where the declaration appears. If the declaration is within a function, it will live until the end of the block that it is declared in, and almost certainly be allocated on the stack; if it's outside a function, it will probably be stored within an "initialised data segment" that is loaded from the executable file into writeable memory when the program is run.

On the other hand, this declaration:

char *s ="hello";

Creates two objects:

• a read-only array of 6 chars containing the values 'h', 'e', 'l', 'l', 'o', '\0', which has no name and has static storage duration (meaning that it lives for the entire life of the program); and
• a variable of type pointer-to-char, called s, which is initialised with the location of the first character in that unnamed, read-only array.

The unnamed read-only array is typically located in the "text" segment of the program, which means it is loaded from disk into read-only memory, along with the code itself. The location of the s pointer variable in memory depends on where the declaration appears (just like in the first example).

Phytosociology

In both declaration for "hello" memory is allocated at comiple time ?.And another thing char *p = "hello" here "hello" is stored in text segment as you stated in your answer...and what about char s[] = "hello" will it also store first in text segment part and during run time it will copy in stack as Rickard has stated in there answer. please clarify this point. – Whiteheaded

@Nishant: In the char s[] = "hello" case, the "hello" is just an initialiser telling the compiler how the array should be initialised. It may or may not result in a corresponding string in the text segment - for example, if s has static storage duration then it is likely that the only instance of "hello" will be in the initialised data segment - the object s itself. Even if s has automatic storage duration, it can be initialised by a sequence of literal stores rather than a copy (eg. movl $1819043176, -6(%ebp); movw $111, -2(%ebp)). – Phytosociology

More precisely, GCC 4.8 puts it into .rodata, which the linker script then dumps into the same segment as .text. See my answer. – Thorwald

@Phytosociology In the first answer by Rickard, It's written that char s[] = "Hello world"; puts the literal string in read-only memory and copies the string to newly allocated memory on the stack. But, your answer only speaks about the literal string put in read-only memory and skips the second part of the sentence which says: copies the string to newly allocated memory on the stack. So, is your answer incomplete for not specifying the second part? – Pecker

@AjaySinghNegi: As I've stated in other comments (to this answer, and Rickard's answer), the string in char s[] = "Hellow world"; is only an initializer and is not necessarily stored as a separate read-only copy at all. If s has static storage duration then the only copy of the string is likely to be in a read-write segment at the location of s, and even if not then the compiler may choose to initialize the array with load-immediate instructions or similar rather than copying from a read-only string. The point is that in this case, the initializer string itself has no runtime presence. – Phytosociology

Answer 4

Given the declarations

char *s0 = "hello world";
char s1[] = "hello world";

assume the following hypothetical memory map (the columns represent characters at offsets 0 to 3 from the given row address, so e.g. the 0x00 in the bottom right corner is at address 0x0001000C + 3 = 0x0001000F):

                     +0    +1    +2    +3
        0x00008000: 'h'   'e'   'l'   'l'
        0x00008004: 'o'   ' '   'w'   'o'
        0x00008008: 'r'   'l'   'd'   0x00
        ...
s0:     0x00010000: 0x00  0x00  0x80  0x00
s1:     0x00010004: 'h'   'e'   'l'   'l'
        0x00010008: 'o'   ' '   'w'   'o'
        0x0001000C: 'r'   'l'   'd'   0x00

The string literal "hello world" is a 12-element array of char (const char in C++) with static storage duration, meaning that the memory for it is allocated when the program starts up and remains allocated until the program terminates. Attempting to modify the contents of a string literal invokes undefined behavior.

The line

char *s0 = "hello world";

defines s0 as a pointer to char with auto storage duration (meaning the variable s0 only exists for the scope in which it is declared) and copies the address of the string literal (0x00008000 in this example) to it. Note that since s0 points to a string literal, it should not be used as an argument to any function that would try to modify it (e.g., strtok(), strcat(), strcpy(), etc.).

The line

char s1[] = "hello world";

defines s1 as a 12-element array of char (length is taken from the string literal) with auto storage duration and copies the contents of the literal to the array. As you can see from the memory map, we have two copies of the string "hello world"; the difference is that you can modify the string contained in s1.

s0 and s1 are interchangeable in most contexts; here are the exceptions:

sizeof s0 == sizeof (char*)
sizeof s1 == 12

type of &s0 == char **
type of &s1 == char (*)[12] // pointer to a 12-element array of char

You can reassign the variable s0 to point to a different string literal or to another variable. You cannot reassign the variable s1 to point to a different array.

Impiety

In your memory map, shouldn't the 4 columns be 0x00 0x01 0x02 0x03 instead of 0x01 0x02 0x03 0x04? Otherwise it looks like s0 points to 0x00008000 but the first letter is at 0x00008001. Likewise, it's unclear whether 0x00008004 is the address of the second 'l' or of the 'o'. – Sternwheeler

Answer 5

C99 N1256 draft

There are two different uses of character string literals:

1. Initialize char[]:

   char c[] = "abc";      
   

   This is "more magic", and described at 6.7.8/14 "Initialization":

   An array of character type may be initialized by a character string literal, optionally enclosed in braces. Successive characters of the character string literal (including the terminating null character if there is room or if the array is of unknown size) initialize the elements of the array.

   So this is just a shortcut for:

   char c[] = {'a', 'b', 'c', '\0'};
   

   Like any other regular array, c can be modified.

2. Everywhere else: it generates an:

   • unnamed
   • array of char What is the type of string literals in C and C++?
   • with static storage
   • that gives UB if modified

   So when you write:

   char *c = "abc";
   

   This is similar to:

   /* __unnamed is magic because modifying it gives UB. */
   static char __unnamed[] = "abc";
   char *c = __unnamed;
   

   Note the implicit cast from char[] to char *, which is always legal.

   Then if you modify c[0], you also modify __unnamed, which is UB.

   This is documented at 6.4.5 "String literals":

   5 In translation phase 7, a byte or code of value zero is appended to each multibyte character sequence that results from a string literal or literals. The multibyte character sequence is then used to initialize an array of static storage duration and length just sufficient to contain the sequence. For character string literals, the array elements have type char, and are initialized with the individual bytes of the multibyte character sequence [...]

   6 It is unspecified whether these arrays are distinct provided their elements have the appropriate values. If the program attempts to modify such an array, the behavior is undefined.

6.7.8/32 "Initialization" gives a direct example:

EXAMPLE 8: The declaration

char s[] = "abc", t[3] = "abc";

defines "plain" char array objects s and t whose elements are initialized with character string literals.

This declaration is identical to

char s[] = { 'a', 'b', 'c', '\0' },
t[] = { 'a', 'b', 'c' };

The contents of the arrays are modifiable. On the other hand, the declaration

char *p = "abc";

defines p with type "pointer to char" and initializes it to point to an object with type "array of char" with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to modify the contents of the array, the behavior is undefined.

GCC 4.8 x86-64 ELF implementation

Program:

#include <stdio.h>

int main(void) {
    char *s = "abc";
    printf("%s\n", s);
    return 0;
}

Compile and decompile:

gcc -ggdb -std=c99 -c main.c
objdump -Sr main.o

Output contains:

 char *s = "abc";
8:  48 c7 45 f8 00 00 00    movq   $0x0,-0x8(%rbp)
f:  00 
        c: R_X86_64_32S .rodata

Conclusion: GCC stores char* it in .rodata section, not in .text.

Note however that the default linker script puts .rodata and .text in the same segment, which has execute but no write permission. This can be observed with:

readelf -l a.out

which contains:

 Section to Segment mapping:
  Segment Sections...
   02     .text .rodata

If we do the same for char[]:

 char s[] = "abc";

we obtain:

17:   c7 45 f0 61 62 63 00    movl   $0x636261,-0x10(%rbp)

so it gets stored in the stack (relative to %rbp).

Thorwald

Answer 6

char s[] = "hello";

declares s to be an array of char which is long enough to hold the initializer (5 + 1 chars) and initializes the array by copying the members of the given string literal into the array.

char *s = "hello";

declares s to be a pointer to one or more (in this case more) chars and points it directly at a fixed (read-only) location containing the literal "hello".

Edbert

What method is preferable to use in functions if s will not be changed, f(const char s[]) or f(const char *s) ? – Supermarket

@psihodelia: In a function declaration there is no difference. In both cases s is a pointer to const char. – Edbert

Answer 7

char s[] = "Hello world";

Here, s is an array of characters, which can be overwritten if we wish.

char *s = "hello";

A string literal is used to create these character blocks somewhere in the memory which this pointer s is pointing to. We can here reassign the object it is pointing to by changing that, but as long as it points to a string literal the block of characters to which it points can't be changed.

Lame

@bo Persson Why the block of characters can't be changed in the second case? – Tenpenny

Answer 8

Just to add: you also get different values for their sizes.

printf("sizeof s[] = %zu\n", sizeof(s));  //6
printf("sizeof *s  = %zu\n", sizeof(s));  //4 or 8

As mentioned above, for an array '\0' will be allocated as the final element.

Moult

Answer 9

As an addition, consider that, as for read-only purposes the use of both is identical, you can access a char by indexing either with [] or *(<var> + <index>) format:

printf("%c", x[1]);     //Prints r

And:

printf("%c", *(x + 1)); //Prints r

Obviously, if you attempt to do

*(x + 1) = 'a';

You will probably get a Segmentation Fault, as you are trying to access read-only memory.

Kaleidoscope

This is in no way different from x[1] = 'a'; which will segfault as well (depending on the platform, of course). – Vaughnvaught

Answer 10

An example to the difference:

printf("hello" + 2); //llo
char a[] = "hello" + 2; //error

In the first case pointer arithmetics are working (arrays passed to a function decay to pointers).

Cush

While this code may answer the question, providing additional context regarding why and/or how this code answers the question improves its long-term value. – Collazo

Answer 11

char *str = "Hello";

The above sets str to point to the literal value "Hello" which is hard-coded in the program's binary image, which is flagged as read-only in memory, means any change in this String literal is illegal and that would throw segmentation faults.

char str[] = "Hello";

copies the string to newly allocated memory on the stack. Thus making any change in it is allowed and legal.

means str[0] = 'M';

will change the str to "Mello".

For more details, please go through the similar question:

Why do I get a segmentation fault when writing to a string initialized with "char *s" but not "char s[]"?

Amylo

Answer 12

char *s1 = "Hello world"; // Points to fixed character string which is not allowed to modify
char s2[] = "Hello world"; // As good as fixed array of characters in string so allowed to modify

// s1[0] = 'J'; // Illegal
s2[0] = 'J'; // Legal

Evaluate

Answer 13

In the case of:

char *x = "fred";

x is an lvalue -- it can be assigned to. But in the case of:

char x[] = "fred";

x is not an lvalue, it is an rvalue -- you cannot assign to it.

Relax

Technically, x is a non-modifiable lvalue. In almost all contexts though, it will evaluate to a pointer to its first element, and that value is an rvalue. – Phytosociology

Answer 14

In the light of comments here it should be obvious that : char * s = "hello" ; Is a bad idea, and should be used in very narrow scope.

This might be a good opportunity to point out that "const correctness" is a "good thing". Whenever and wherever You can, use the "const" keyword to protect your code, from "relaxed" callers or programmers, which are usually most "relaxed" when pointers come into play.

Enough melodrama, here is what one can achieve when adorning pointers with "const". (Note: One has to read pointer declarations right-to-left.) Here are the 3 different ways to protect yourself when playing with pointers :

const DBJ* p means "p points to a DBJ that is const" 

— that is, the DBJ object can't be changed via p.

DBJ* const p means "p is a const pointer to a DBJ" 

— that is, you can change the DBJ object via p, but you can't change the pointer p itself.

const DBJ* const p means "p is a const pointer to a const DBJ" 

— that is, you can't change the pointer p itself, nor can you change the DBJ object via p.

The errors related to attempted const-ant mutations are caught at compile time. There is no runtime space or speed penalty for const.

(Assumption is you are using C++ compiler, of course ?)

--DBJ

War

This is all correct, but it has nothing to do with the question. And as far as your assumption about a C++ compiler, the question is tagged as C, not as C++. – Sternwheeler

There is nothing bad about char *s = "const string"; – Duodiode