What is the lifetime of the result of std::string::c_str()?
The c_str()
result becomes invalid if the std::string
is destroyed or if a non-const member function of the string is called. So, usually you will want to make a copy of it if you need to keep it around.
In the case of your example, it appears that the results of c_str()
are used safely, because the strings are not modified while in that scope. (However, we don't know what use_foo()
or ~Foo()
might be doing with those values; if they copy the strings elsewhere, then they should do a true copy, and not just copy the char
pointers.)
Technically your code is fine.
BUT you have written in such a way that makes it easy to break for somebody that does not know the code. For c_str() the only safe usage is when you pass it as a parameter to a function. Otherwise you open yourself up-to maintenance problems.
Example 1:
{
std::string server = "my_server";
std::string name = "my_name";
Foo foo;
foo.server = server.c_str();
foo.name = name.c_str();
//
// Imagine this is a long function
// Now a maintainer can easily come along and see name and server
// and would never expect that these values need to be maintained as
// const values so why not re-use them
name += "Martin";
// Oops now its broken.
// We use foo
use_foo(foo);
// Foo is about to be destroyed, before name and server
}
So for maintenance make it obvious:
Better solution:
{
// Now they can't be changed.
std::string const server = "my_server";
std::string const name = "my_name";
Foo foo;
foo.server = server.c_str();
foo.name = name.c_str();
use_foo(foo);
}
But if you have const strings you don't actually need them:
{
char const* server = "my_server";
char const* name = "my_name";
Foo foo;
foo.server = server;
foo.name = name;
use_foo(foo);
}
OK. For some reason you want them as strings:
Why not use them only in the call:
{
std::string server = "my_server";
std::string name = "my_name";
// guaranteed not to be modified now!!!
use_foo(Foo(server.c_str(), name.c_str());
}
It is valid until one of the following happens to the corresponding string
object:
- the object is destroyed
- the object is modified
You're fine with your code unless you modify those string
objects after c_str()
s are copied into foo
but before use_foo()
is called.