在C中将字符串分配给字符指针的说明

Question

I am very much confused with pointers. If we create a pointer variable of type 'char', that is some thing like char *ch; and assign a character array to it. Then we can access each letter in the string by increasing the pointer (++ch).

char *ch;
char a[5]="hello";
*ch=a;
while(*ch) {
  printf("%c",*ch);
  ++ch;
}

This works perfectly fine. But I see many examples like,

struct example {
  char *ch;
};

int main() {
  struct example ex={"hello"};
  printf("%s",ex.ch);
}

I am pretty confused with this example like how directly assigning a string to a character pointer(instead of assigning the string to a variable and then assigning it to character pointer) can make it accessible. In the previous case, *ch points to the starting memory of the array "a". But in the second case to which memory does the pointer ch point to? Can anyone give me a clear explanation?

Answer 1

When you make this assignment

ch=a;

you are setting the pointer ch to the beginning of the character array a[] (note: the fact that the array remains null-terminated is a pure coincidence - your code has undefined behavior, because the sixth character '\\0' at the end of "hello" is not copied into a five-character array). After the assignment ch becomes an "alias" to the C string stored inside the array a[] , which means that you can use it with string manipulation and formatting routines.

Your second example is not an assignment, it is initialization:

struct example ex={"hello"};

Enclosed in curly braces is an initializer. C compiler will take each element (you've got only one, but there can be many) and assign it to the corresponding field of the struct . In this case, string literal "hello" is assigned to the ch member.

The rule for initializers is to assign the values in curly braces in declaration order. You have an opportunity to override it if you wish by using the designated initializer feature of C99:

struct example ex={ .ch = "hello"};

Answer 2

This code snippet

char *ch;
char a[5]="hello";
*ch=a;
while(*ch)
{
printf("%c",*ch);
++ch;

}

has undefined behaviour. That it would work fine you have to declare the character array either as

char a[6]="hello";

or char a[]="hello";

In this case the array indeed will have the terminating zero.

As for this code snippet

struct example
{
char *ch;
};
int main()
{
struct example ex={"hello"};
printf("%s",ex.ch);
}

then in this statement

struct example ex={"hello"};

the compiler at first places string literal "hello" in memory as a character array having type char[6] and then assign pointer to the first element of the array to data member ch of the structure.

The difference between these two declarations

char ch[] = "hello";

and

char *ch = "hello";

is that that in the first case a character array is created each element of which is initialized by corresponding character of the string literal that itself will not be stored in memory. In the second case the string literal will be stored in memory and pointer ch will contain the address of its first character.

Answer 3

char a[] = "hi";
char *ch = "hello";

Here a is a char array of size 3 bytes to store, ' h ', ' i ' and ' \\0 '. 3 bytes of this memory is allocated in stack to keep the string.

Here ch is a pointer variable, which store a address of char, and size of ch is 4 bytes to store the address (size of pointer is compiler specific). Then " hello " is a constant string literal which will be in text segment of process memory as a read only data. And the address of the first byte is assigned to ch variable. 4 byte of memory is allocated for ch variable to store address in stack and 5 byte of memory is required in text segment to keep the string literal " hello ".

For explanation in some other views read here .