5

I am working on a project with existing code which uses mainly C++ but with c-style strings. Take the following:

#include <iostream>
int main(int argc, char *argv[])
{
    char* myString = "this is a test";
    myString = "this is a very very very very very very very very very very very long string";
    cout << myString << endl;
    return 0;
}

This compiles and runs fine with the output being the long string.

However I don't understand WHY it works. My understanding is that

char* myString

is a pointer to an area of memory big enough to hold the string literal "this is a test". If that's the case, then how am I able to then store a much longer string in the same location? I expected it to crash when doing this due to trying to cram a long string into a space set aside for the shorter one.

Obviously there's a basic misunderstanding of what's going on here so I appreciate any help understanding this.

Improve this question
2
  • Shouldn't this be tagged "c++" and "c-string" instead of "c" and "string"? This question is about C++, not about C. Commented Nov 15, 2011 at 20:56
  • @WTP - you're right, I've edited the tags accordingly. Commented Nov 16, 2011 at 19:01

6 Answers 6

Reset to default
14

You're not changing the content of the memory, you're changing the value of the pointer to point to a different area of memory which holds "this is a very very very very very very very very very very very long string".

Note that char* myString only allocates enough bytes for the pointer (usually 4 or 8 bytes). When you do char* myString = "this is a test";, what actually happened was that before your program even started, the compiler allocated space in the executable image and put "this is a test" in that memory. Then when you do char* myString = "this is a test"; what it actually does is just allocate enough bytes for the pointer, and make the pointer point to that memory it had already allocated at compile time, in the executable.

So if you like diagrams:

char* myString = "this is a test";

(allocate memory for myString)

              ---> "this is a test"
            / 
myString---

                   "this is a very very very very very very very very very very very long string"

Then

myString = "this is a very very very very very very very very very very very long string";

                   "this is a test"

myString---
            \
              ---> "this is a very very very very very very very very very very very long string"
Improve this answer
Sign up to request clarification or add additional context in comments.

6 Comments

Ah! That makes sense. So when that happens, is the memory that was allocated to the original "this is a test" string automatically freed?
@DTJon no, it still exists in the executable, and will never change throughout the entire program. This is why you can never do char* a = "something"; a[1] = 'f'; because a points to some read-only memory, and you're not allowed to change its contents.
Well, read-only memory is an impl. detail but it is UB to modify a literal.
The size of a pointer is implementation-dependent and may be 4B. Will upvote if you either fix it or prove you're correct.
@WTP it would be impossible to prove I'm correct because I am incorrect :)
|
5

There are two strings in the memory. First is "this is a test" and lets say it begins at the address 0x1000. The second is "this is a very very ... test" and it begins at the address 0x1200.

By 

char* myString = "this is a test";

you crate a variable called myString and assign address 0x1000 to it. Then, by 

myString = "this is a very very ... test";

you assign 0x1200. By

cout << myString << endl;

you just print the string beginning at 0x1200.

Improve this answer

Comments

2

You have two string literals of type const char[n]. These can be assigned to a variable of type char*, which is nothing more than a pointer to a char. Whenever you declare a variable of type pointer-to-T you are only declaring the pointer, and not the memory to which it points.

The compiler reserves memory for both literals and you just take your pointer variable and point it at those literals one after the other. String literals are read-only and their allocation is taken care of by the compiler. Typically they are stored in the executable image in protected read-only memory. A string literal typically has a lifetime equal to that of the program itself.

Now, it would be UB if you attempted to modify the contents of a literal, but you don't. To help prevent yourself from attempting modifications in error you would be wise to declare your variable as const char*.

Improve this answer

2 Comments

Aren't the literals of type char const[x] rather than const char*? Or did I get confused about those two.
@Seth You are correct. Of course arrays decay to pointers so there's little difference.
2

During program execution, a block of memory containing "this is a test" is allocated, and the address of the first character in that block of memory is assigned to the myString variable. In the next line, a separate block of memory containing "this is a very very..." is allocated, and the address of the first character in that block of memory is now assigned to the myString variable, replacing the address it used to store with the new address to the "very very long" string.

just for illustration, let's say the first block of memory looks like this:

[t][h][i][s][ ][i][s][ ][a][ ][t][e][s][t] and let's just say the address of this first 't' character in this sequence/array of characters is 0x100. so after the first assignment of the myString variable, the myString variable contains the address 0x100, which points to the first letter of "this is a test".

then, a totally different block of memory contains:

[t][h][i][s][ ][i][s][ ][a][ ][v][e][r][r][y]... and let's just say that the address of this first 't' character is 0x200. so after the second assignment of the myString variable, the myString variable NOW contains the address 0x200, which points to the first letter of "this is a very very very...".

Since myString is just a pointer to a character (hence: "char *" is it's type), it only stores the address of a character; it has no concern for how big the array is supposed to be, it doesn't even know that it is pointing to an "array", only that it is storing the address of a character...

for example, you could legally do this:

    char myChar = 'C';
/* assign the address of the location in 
   memory in which 'C' is stored to 
   the myString variable. */
    myString = &myChar;

Hopefully that was clear enough. If so, upvote/accept answer. If not, please comment so that I may clarify.

Improve this answer

Comments

1

string literals do not require allocation - they are stored as-is and can be used directly. Essentially myString was a pointer to one string literal, and was changed to point to another string literal.

Improve this answer

Comments

0

char* means a pointer to a block of memory that holds a character.

C style string functions get a pointer to the start of a string. They assume there's a sequence of characters that end with a 0-null character (\n).

So what the << operator actually does is loop from that first character position until it finds a null character.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.