我有以下代码:

std::string getString() {
    std::string str("hello");
    return str;
}

int main() {
    const char* cStr = getString().c_str();
    std::cout << cStr << std::endl; // this prints garbage
}

我认为 getString() 会返回 str 的拷贝 (getString() 按值返回)；因此，str 的拷贝将在 main() 中保持“事件”状态，直到 main() 返回。这将使 cStr 指向一个有效的内存位置:底层 char[] 或 char* (或其他) str 由 getString() 返回，保留在 main() 中。

但是，显然不是这样，因为程序输出的是垃圾。那么，问题是，str 何时被销毁，为什么？

最佳答案

getString() would return a copy of str (getString() returns by value);

没错。

thus, the copy of str would stay "alive" in main() until main() returns.

不，返回的拷贝是临时的 std::string , 将在创建它的语句末尾销毁，即在 std::cout << cStr << std::endl; 之前.然后 cStr变得悬垂，对它的取消引用会导致UB，一切皆有可能。

您可以将返回的临时变量复制到命名变量，或将其绑定(bind)到 const左值引用或右值引用(临时对象的生命周期将延长，直到引用超出范围)。如:

std::string s1 = getString();    // s1 will be copy initialized from the temporary
const char* cStr1 = s1.c_str();
std::cout << cStr1 << std::endl; // safe

const std::string& s2 = getString(); // lifetime of temporary will be extended when bound to a const lvalue-reference
const char* cStr2 = s2.c_str();
std::cout << cStr2 << std::endl; // safe

std::string&& s3 = getString();  // similar with above
const char* cStr3 = s3.c_str();
std::cout << cStr3 << std::endl; // safe

或者在临时对象被销毁之前使用指针。例如

std::cout << getString().c_str() << std::endl;  // temporary gets destroyed after the full expression

这是来自 [The.C++.Programming.Language.Special.Edition] 10.4.10 Temporary Objects [class.temp]] 的解释:

Unless bound to a reference or used to initialize a named object, a temporary object is destroyed at the end of the full expression in which it was created. A full expression is an expression that is not a subexpression of some other expression.

The standard string class has a member function c_str() that returns a C-style, zero-terminated array of characters (§3.5.1, §20.4.1). Also, the operator + is defined to mean string concatenation. These are very useful facilities for strings . However, in combination they can cause obscure problems. For example:

void f(string& s1, string& s2, string& s3)
{

    const char* cs = (s1 + s2).c_str();
    cout << cs ;
    if (strlen(cs=(s2+s3).c_str())<8 && cs[0]==´a´) {
        // cs used here
    }

}

Probably, your first reaction is "but don’t do that," and I agree. However, such code does get written, so it is worth knowing how it is interpreted.

A temporary object of class string is created to hold s1 + s2 . Next, a pointer to a C-style string is extracted from that object. Then – at the end of the expression – the temporary object is deleted. Now, where was the C-style string allocated? Probably as part of the temporary object holding s1 + s2 , and that storage is not guaranteed to exist after that temporary is destroyed. Consequently, cs points to deallocated storage. The output operation cout << cs might work as expected, but that would be sheer luck. A compiler can detect and warn against many variants of this problem.

关于c++ - 为什么在返回字符串的函数上调用 std::string.c_str() 不起作用？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/35980664/