Lifetime of returned strings and their .c_str()

Question

I've come across multiple instance of this pattern (with boost::filesystem only used as example):

boost::filesystem::path path = ...;
someFunctionTakingCStrings(path.string().c_str());

where

const std::string path::string() const
{
  std::string tmp = ...
  return tmp;
}

Although I have never experienced problem with this pattern, I was wondering when the string returned by sting() is destroyed and whether the code accessing the c_str() is safe as the c_str() lifetime is bound to std::string lifetime.

Answer 1

someFunctionTakingCStrings(path.string().c_str()); is safe since the standard guarantees that the lifetime of the anonymous temporary path.string() survives the function call. So the pointer returned by c_str() is a valid parameter for someFunctionTakingCStrings.

const std::string path::string() const is safe since, conceptually, you are returning a value copy of tmp, although in practice a compiler will optimise out the value copy (a process called named return value optimisation).

Something like const std::string& path::string() const with the same function body as the one you have would not be defined (since the reference would dangle), and

const char* ub_server()
{
    std::string s = "Hello";
    return s.c_str();
}

is also undefined, as s is out of scope by the time the function returns.

Finally, note that taking a pointer to an anonymous temporary as a parameter in a function call is not allowed in standard C++ although annoyingly, Visual C++ allows it as an extension.