70

Is the following C++ code well-formed:

void consumer(char const* p)
{
  std::printf("%s", p);
}

std::string random_string_generator()
{
  // returns a random std::string object
}

consumer(random_string_generator().c_str());

The problem I have with it is, that after creating the temporary std::string object and taking the c_str() pointer, nothing prevents the std::string object from getting destroyed (or maybe I'm wrong?). Can you please point me to the standard, if the code is OK despite everything. It does work, when I test with g++.

user1095108
  • 14,119
  • 9
  • 58
  • 116

3 Answers3

90

The pointer returned by std::string::c_str() points to memory maintained by the string object. It remains valid until a non-const function is called on the string object, or the string object is destructed. The string object you're concerned about is a temporary. It will be destructed at the end of the full expression, not before and not after. In your case, the end of the full expression is after the call to consumer, so your code is safe. It wouldn't be if consumer saved the pointer somewhere, with the idea of using it later.

The lifetime of temporaries has been strictly defined since C++98. Before that, it varied, depending on the compiler, and the code you've written wouldn't have worked with g++ (pre 1995, roughly—g++ changed this almost immediately when the standards committee voted it). (There wasn't an std::string then either, but the same issues affect any user written string class.)

James Kanze
  • 150,581
  • 18
  • 184
  • 329
  • what if one used the `c_str()` `const char*` in a subsequent statement (still inside the function, but outside the first statement)? Would this bring us a dangling pointer? – Alex Gidan Feb 20 '19 at 16:04
  • I answer myself... In that case it would be invalid: _§ 12.2 ... Temporary objects are destroyed as the last step in evaluating the full-expression (1.9) that (lexically) contains the point where they were created. This is true even if that evaluation ends in throwing an exception._ – Alex Gidan Feb 20 '19 at 16:53
  • std::string temp = random_string_generator().c_str(); Is this correct to assume temp would be correct? since the life time of the string returned from random_string_generator() will be till the end of expression? – Ayush Pant Jun 17 '21 at 20:44
  • @AyushPant, yes. The `const char*` is valid when initializing `temp` which copies the characters. But why not just move the string returned by the function? – Quirin F. Schroll Jan 17 '23 at 13:40
25

The temporary std::string's lifetime extends just beyond the point where consumer returns, so it is safe to use anything on that string directly from within consumer. What is not OK is to store the value that c_str returns and try to use it later (the temporary will have been destroyed, and we can only guess what you will find at the other end of the pointer).

Jon
  • 428,835
  • 81
  • 738
  • 806
  • 1
    can you provide a hint as regards the C++03 or the C++11 standard please? – user1095108 Apr 04 '12 at 07:53
  • 5
    The lifetime of a temporary is defined in §12.2. (Section 12 is entitled "Special member functions", which isn't exactly where you'd expect to look for lifetime of temporaries, but that's where it is.) – James Kanze Apr 04 '12 at 07:56
  • @user1095108 and lifetime of function arguments can be obtained from §3.2.2 and §3.7.2 in the c++03 standard. – juanchopanza Apr 04 '12 at 08:24
6

The temporary returned by the function random_string_generator() can be used in consumer() function safely.

dgulabs
  • 443
  • 4
  • 16