C++ String Literal Changing After Function Terminates - c++

Question

I have three functions like this:
MyStruct foo() {
//do something...
return get_var("string literal");
}
MyStruct get_var(const string &literal) {
return (MyStruct) {some_attribute, &*literal.begin(), literal.size()}; //struct needs const char*
}
void bar() {
Mystruct var;
//do stuff
var = foo();
std::cout << var.string_attribute;
}
This should print "string literal", but instead, the first half of the string is a random jumble of characters.
If I do this:
MyStruct get_var(const string &literal) {
std::cout << literal;
return (MyStruct) {some_attribute, &*literal.begin(), literal.size()}; //struct needs const char*
}
It prints correctly only the first time. and if I do this:
MyStruct foo() {
//do something...
string my_literal = "string literal";
std::cout << my_literal;
return get_var(my_literal);
}
It prints correctly the first and second times, but not the third. I have no idea what's happening; I thought string literals lasted forever, so it shouldn't be overwritten or anything.
Any help is greatly appreciated.

Answer 1

c++ is an old language that grew out of C, the result is that both the behavior and the terminology used to describe that behavior can be rather confusing.
A "string literal" is a sequence of characters in the source code surrounded by quotes. In most contexts it evaluates to a pointer to a null-terminated sequence of characters (a "C string"). Under normal circumstances* said sequence of characters will indeed remain valid for the entire lifetime of the progream.
The type string in your code on the other hand is probably referring to std::string (via using namespace std somewhere) which is a class representing an automatically managed string
When you do get_var("string literal"); or string my_literal = "string literal"; the "C string" is implicitly converted to a std::string. This operation creates a copy of the sequence of characters. Unlike the original sequence of characters this sequence of characters will be freed when the std::string that owns it is destroyed.
&*literal.begin is a somewhat unorthadox way to get a pointer to the sequence of characters owned by the std::string. using c_str would be more normal. That isn't relevant to your problem though. The important bit is the sequence of characters in memory is one owned by the std::string, not the original sequence from the string literal.
In the case of get_var("string literal"); the std::string is destroyed as soon as the statement completes. In the case of string my_literal = "string literal"; it is destroyed when the variable my_literal goes out of scope. Either way it is destroyed before foo() returns. So when you do std::cout << var.string_attribute; you are referencing a stale pointer for which the associated memory has already been freed.
The reason it works "sometimes" is that memory managers do not generally overwrite memory as soon as it is freed. Typically the memory is not actually overwritten until something re-uses it.
Edit: misread your question. It is possible for a use-after free to "work" sometimes but that is not what is going on here. The cout calls you say are working are at points in the code where the std::string is still alive.
* Excluding cases like unloading shared libraries at runtime that are beyond the scope of the C standard.

Answer 2

Enable maximum compiler warnings. It should alert you to the fact that you're trying to return a pointer to a temporary.
The line string my_literal = "string literal"; creates a string, then passes a const reference to that string into the function. Then at the end of foo(), my_literal is DESTROYED. It is GONE. Any pointers to that are now INVALID.
Absolutely any bad thing can happen after that, it is undefined behavior.