Consider this code:
char* f(char* str)
{
return ++str;
}
int main()
{
char* str = "test";
str = f(str);
//flag
return 0;
}
At 'flag' what happens with the memory address where the first original 't' resides? Will it be free-ed or will it be a 'stack leak'?
char *str = "test";
There are 2 objects "in play" here: the str object of type char* (pointer to char) and the unnamed object of type char[5].
The unnamed array object (with contents {'t', 'e', 's', 't', 0}), when used as initialization value for a pointer get converted to a pointer to its first element and it's that address that gets copied to str.
There is no allocation of memory, so there is no chance of having memory leaking!
str is associated with an area of memory 5-bytes long but the management of that area is done automatically by the implementation; the programmer does not need to think about it -- it gets automagically created when the statement "is executed" and gets automagically destroyed when the encompassing } is reached.malloc() and friends. For example: int main(void) { char giga[1024*1024*1024]; } will probably fail in contrast with int main(void) { char *giga = malloc(1024*1024*1024); frre(giga); }The string literal "test" will be welded into the executable, and the OS will place it in read-only memory (that's why attempts to modify string literals often trigger a segmentation fault) while loading the file. The OS is also responsible for properly unloading the data.
So, that data is not placed on the stack, but char* str is. Since it's a regular local variable, it'll be deallocated automatically by the code inserted by the compiler.
To answer the question: at //flag the whole content of "test" will still be present at the same address initially allocated by the OS, and the stack won't be involved here at all. While processing the return statement, the compiler will insert code to clean up the stack.
"test" will always be embedded into your executable and later stored in read-only memory by the OS.
char* str = "test";allocate the string in the read only memory. Only the pointerstris allocated on stack, and its value is updated from the call to the functionf(). No stack change happen.