Thread: The Mysterious char*

I have always been confused about the working of char* pointer.
It seems to behave quite strangely.

Unlike the int or float pointer, the char* pointer seems to be able to store an address and also a string?
1.can some one explain this dual behavior of char*?

Code:

Program

int main( )
{
char* p;

//Works
p="Hello";

//Prints correctly
cout<<p;

//Does not work
cin>>p;

return 0;

}

2.why p="Hello" works? its a pointer shouldn't it give an error because "hello" is not an address, its a string?

3. And why cin>>p doesn't work?

Because "strings" are arrays, and as you know, an array reference decays into a pointer to the first element of that array.

The compiler takes each "string", and effectively turns it into

Code:

static const char anonymous_string_1[] = { 'H', 'e', 'l', 'l', 'o', '\0' };

So when you write
p="Hello";
the compiler has done something like
p = anonymous_string_1;


> 3. And why cin>>p doesn't work?
Because the "string" is a const, and you can't modify things which are constant.
On most systems, a "string" is also stored in read-only memory. Attempting to write to it causes the OS to just kill the program with a segmentation fault (or similar).

Doesn't the second sentence contradict the first ?

How so?

The first part describes the behavior of all pointers with respect `char *'.

The second part describes the syntactical sugar the language provides to define a "C string" which is an array.

The array isn't a pointer; it decays into a pointer. The type `const char[6]' is not the same as the type `const char *'. However, the type `const int[6]' behaves with respect to `const int *' in the same ways.

I mean, you can't give cout an address to a null terminated integer array and expect the array to be printed.

Yes, you can.

A "C string" is a convention that says "This is an array of unknown length terminated by a null character.". The "null" character is just a value. The operation you reference conceptually reads values one character at a time from the known location and prints them until the terminating character is found.

If you choose to define an "integer series" as a sequence of values terminated by `~static_cast<uint_t>(0)' a function for this sequence that follows the same conceptual logic can be made.

[Edit]
For context, by using Salem's post, here is bit more information.

Code:

static const char anonymous_string_2[] = {'H', 'e', 'l', 'l', 'o'};

The array `anonymous_string_2' is not a "C string"; the array `anonymous_string_2' is of type `const char[5]' and decays into the pointer `const char *' exactly as `anonymous_string_1'.
[/Edit]

Soma