C++: Changing value of Pointer Strings

Question

There is something that has been bugging me for a while and I need an anwer for it,

char *p = "hello world";
p="wazzup";
p="Hey";

Here I declare an pointer to point to a string (or in other words I made a string by using a pointer)

I have had some strange results with this that i normally wouldnt have gotten if I used an char array string

cout <<p<< endl; //"Hey" Gets printer
cout <<p+8<< endl; // I kept adding numbers till "wazzup" got printed
cout <<p+29<< endl; // No matter how much I increment, I cant print "Hello World"

So my question is:

When I change the value that a char pointer is pointing to. Does it

• overwrite the original Data like it would do with char array;

• or it creates a new string right before it in the memory and points to it;

• or does it add the new string at the begining of the old one(including null);

• or does it create a new string in a new place in the memory and I was able to print "wazzup" only by chance

Answer 1

By adding to the pointer, you are increasing the address value... so while printing it will print the value stored at that memory location and nothing else...

If you could print

"hello world"
"wazzup"

that will be a fluke :)

Answer 2

Since they 3 are not same strings, they are located at different parts of memory. I think they could be separated by 64 byte aligning. try p+64 :)

Only same strings sit in the same location of memory and only if compiler supports it.

There is a probability "wazzup" at p+64 and "hey" at p+128(if you use VC++ 2010 express and you have pentium-m cpu and you use windows xp sp-3)

cout <<*(p+64)<< endl;
cout <<*(p+128)<< endl;

Answer 3

The three strings are not located in same memory position. This three memory may be sequential or different location.If compiler allocation three memory then you find it using +/- some value. It totally depends on compiler. In c you can ready any memory location so you never get any error while +/- then pointer p.

Answer 4

When I change the value that a char pointer is pointing to. Does it

-overwrite the original Data like it would do with char array. No, the data part of your address space contains all the three strings "Hello World", "wazzup", and "Hey". When you change the pointer, you are just changing the value in p to the starting address of either of above strings. Changing the address a pointer is pointing to and changing the value a pointer is pointing to are two different things.

-or it creates a new string right before it in the memory and points to it. The compiler creates the strings(character bytes) at the compile time and NOT at run-time.

-or does it create a new string in a new place in the memory and I was able to print "wazzup" only by chance I think above answer covers this question.

-or does it add the new string at the begining of the old one.(including null) It depends on the compiler specification.

Answer 5

You are only making the pointer point to something else each time you assign to it. So there is no scope for data being overwritten anywhere. What happens under the hood is implementation dependent, so what you see is just by pure chance. When you do this:

cout <<p+8<< endl;

you are going beyond the bounds of the string literal, invoking undefined behaviour.

Answer 6

All three of these are string literal constants. They appear directly in your executable's binary, and each time you assign p, you point to these locations in memory. They are completely separate memory; reassigning p to another one does not modify any string data.

Answer 7

It does none of the options above. Changing the value of a pointer merely changes to the address in memory it points to. In each case of the assignments to p, it is set to point to the first character of a (different) string literal - which is stored in memory.

The behaviour of using a pointer that points beyond the end a string literal such as

cout <<p+8<< endl

is undefined. This is why using pointers is fraught with danger.

The behaviour you are seeing is implementation dependant: The compiler stores the strings literals adjacent in memory, so running off the end of one runs into another. Your program might equally have crashed when compiled with a different compiler.