Is Using `std::string::c_str()` with a Temporary String Safe in C ?

Preserving the Integrity of Temporary Strings: Exploring std::string::c_str()

In the realm of C , the safety and validity of code involving temporary strings often raise concerns. One such question surrounds the usage of std::string::c_str() within the context of temporary strings.

The Question:

Consider the following code snippet:

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

std::string random_string_generator();

consumer(random_string_generator().c_str());

The dilemma stems from the potential destruction of the temporary std::string object after retrieving its c_str() pointer. Does this pose a validity concern according to the C standard?

The Answer:

Understanding the lifetime of temporaries is crucial. In C , temporaries are destructed at the end of the full expression, not immediately after their creation or before their usage. Therefore, in the given code, the temporary std::string object will persist until the conclusion of the function call to consumer().

The pointer obtained via std::string::c_str() remains valid until any non-const operation is performed on the string object or it is destructed. Since the string object is temporary and destructed at the end of the full expression, the code is indeed well-formed and valid.

Historical Footnote:

It's important to note that the behavior described above became standardized with C 98. Prior to that, the lifetime of temporaries varied based on the compiler implementation. However, as the standard matured, the behavior was uniformly defined, ensuring consistency across compilers.

The above is the detailed content of Is Using `std::string::c_str()` with a Temporary String Safe in C ?. For more information, please follow other related articles on the PHP Chinese website!