Mryntu

#include <iostream>

std::string get_data()

 return "Hello";


int main()

 const char* data = get_data().c_str();
 std::cout << data << "n";
 return 0;

"Hello" is printing on my machine; however, I am led to believe that this behavior is unspecified i.e. implementation-specific. Am I correct or will it always print "Hello", judging that the returned string is immutable and as such qualified as something that is constant? Thanks in advance!

The code exhibits undefined behavior.

get_data() returns a temporary which expires at the end of the full expression (*):

const char* data = get_data().c_str() ;
// ^~~~~~~~~~ ^
// this evaluates |
// to a prvalue |
// temporary expires here

data points to an internal of that object, so after the temporary ends you are left with a dangling pointer. Accessing it leads to Undefined Behavior. So the next line std::cout << data << "n"; makes the whole program exhibit Undefined Behavior.

*) There is an exception to this rule which doesn't apply here. If a prvalue is directly bound to a reference, the lifetime of the prvalue is extended to the lifetime of the reference.

For instance, this would have been fine:

int main()

 const std::string& ref = get_data();
 const char* data = ref.c_str();
 std::cout << data << "n";
 return 0;

Yes it is, but not the way you're doing it.

If you did this:

std::cout << get_data().c_str() << 'n';

you'd be just fine.

That's because a temporary is guaranteed to live for the lifetime of the full expression it was created in. It may live longer in certain, very specific circumstances.

If you bind a reference to a temporary, it's lifetime will be extended to be the lifetime of the name it was bound to. So, code like this:

std::string const &x = get_data();
std::cout << x.c_str() << 'n';

would also work because the temporary returned by get_data would be bound to the reference named x, and so as long as x remained a valid name to use, the temporary would still exist.