通过const左值引用返回是否会延长变量生命周期？含代码场景问询

Great question! This is one of the most common gotchas in C++, so let's break it down clearly with concrete examples.

核心前提：只有临时对象（右值）的生命周期会被延长 #

First off, the rule about extending an object's lifetime with a const lvalue reference only applies to temporary objects (rvalues). These are unnamed objects—think literal values, expression results, or explicitly created temporary instances (like MyClass()). When you bind a const lvalue reference to one of these, the C++ standard guarantees the temporary's lifetime will be extended to match the lifetime of the reference itself.

那通过const左值引用返回局部变量，会延长它的生命周期吗？ #

Absolutely not. If you return a const lvalue reference to a named local variable (like your x), that variable is an lvalue, not a temporary. The lifetime extension rule doesn't apply here, and you'll end up with a dangling reference.

Let's look at a dangerous example to see why:

#include <iostream>
using namespace std;

const int& get_local_x() {
    int x = 42; // x is a named local lvalue
    return x;   // Returning a reference to x
}

int main() {
    const int& ref = get_local_x(); 
    // x was destroyed when get_local_x() exited—ref is now dangling!
    cout << ref << endl; // Undefined behavior: might print garbage, crash, etc.
}

When get_local_x() finishes, its stack frame (including x) is wiped. The reference ref in main points to invalid memory, and accessing it is a bug waiting to happen. No lifetime extension occurs here because x is a named lvalue, not a temporary.

那什么时候const左值引用会延长生命周期？ #

Only when you're binding it to a temporary object. Here's a valid, safe example:

#include <iostream>
using namespace std;

const int& get_temp() {
    return 42; // 42 is a temporary rvalue
}

int main() {
    const int& ref = get_temp();
    // The temporary 42's lifetime is extended to match ref's lifetime
    cout << ref << endl; // Safely prints 42
}

Another common scenario with class instances:

#include <iostream>
using namespace std;

struct MyClass {
    MyClass() { cout << "MyClass created\n"; }
    ~MyClass() { cout << "MyClass destroyed\n"; }
};

const MyClass& get_temp_class() {
    return MyClass(); // Temporary MyClass instance
}

int main() {
    cout << "Entering main\n";
    const MyClass& ref = get_temp_class();
    cout << "Exiting main\n";
}

The output will be:

Entering main
MyClass created
Exiting main
MyClass destroyed

This proves the temporary's lifetime was extended until ref goes out of scope at the end of main.

关键要点总结 #

• const lvalue references only extend the lifetime of temporary objects (rvalues).
• Binding a const lvalue reference to a named lvalue (like a local variable x) does not extend that variable's lifetime. If the lvalue is destroyed (e.g., a local variable going out of scope), the reference becomes dangling.
• Returning a const lvalue reference to a local variable is always a bug—avoid it at all costs!

内容的提问来源于stack exchange，提问作者user9224744