为什么临时对象的生命周期不会延长到封闭对象的生命周期？

Question

我知道临时不能绑定到非常量引用，但它可以绑定到const引用。也就是说，

 A & x = A(); //error
 const A & y = A(); //ok

我也知道在第二种情况（上面）中，从 A() 创建的临时对象的生命周期一直延伸到 const 引用的生命周期（即 y ）。

但我的问题是：

绑定到临时对象的 const 引用是否可以进一步绑定到另一个 const 引用，从而将临时对象的生命周期延长到第二个对象的生命周期？

我尝试了这个，但没有成功。我不太明白这一点。我写了这段代码：

struct A
{
   A()  { std::cout << " A()" << std::endl; }
   ~A() { std::cout << "~A()" << std::endl; }
};

struct B
{
   const A & a;
   B(const A & a) : a(a) { std::cout << " B()" << std::endl; }
   ~B() { std::cout << "~B()" << std::endl; }
};

int main() 
{
        {
            A a;
            B b(a);
        }
        std::cout << "-----" << std::endl;
        {
            B b((A())); //extra braces are needed!
        }
}

输出（ideone）：

 A()
 B()
~B()
~A()
-----
 A()
 B()
~A()
~B()

输出差异？为什么在第二种情况下，临时对象A()会先于对象b被销毁？标准 (C++03) 是否讨论了这种行为？

Answer 1

该标准考虑了两种延长临时生命周期的情况：

§12.2/4 有两种上下文，其中临时变量在与完整表达式末尾不同的点被销毁。第一个上下文是当表达式作为定义对象的声明符的初始值设定项出现时。在这种情况下，保存表达式结果的临时变量将持续存在，直到对象的初始化完成。 [...]

§12.2/5 第二个上下文是引用绑定到临时对象时。 [...]

这两个都不允许您通过稍后将引用绑定到另一个 const 引用来延长临时引用的生命周期。但忽略标准并想想正在发生的事情：

临时对象是在堆栈中创建的。好吧，从技术上讲，调用约定可能意味着适合寄存器的返回值（临时）甚至可能不会在堆栈中创建，但请耐心等待。当您将常量引用绑定到临时变量时，编译器在语义上会创建一个隐藏的命名变量（这就是为什么复制构造函数需要可访问，即使它没有被调用）并将引用绑定到该变量。是否实际创建或删除副本是一个细节：我们拥有的是一个未命名局部变量和对它的引用。

如果标准允许您的用例，那么这意味着临时变量的生命周期必须一直延长，直到最后一次引用该变量。现在考虑示例的这个简单扩展：

B* f() {
   B * bp = new B(A());
   return b;
}
void test() {
   B* p = f();
   delete p;
}

现在的问题是临时变量（我们称其为 _T）绑定在 f() 中，它的行为就像那里的局部变量。该引用绑定在*bp内部。现在该对象的生命周期超出了创建临时对象的函数，但因为 _T 不是动态分配的，所以这是不可能的。

您可以尝试并推理出在此示例中延长临时对象的生命周期所需的工作量，答案是如果没有某种形式的 GC，就无法完成此任务。

Answer 2

不，延长的寿命不会通过传递参考而进一步延长。

在第二种情况下，临时变量绑定到参数 a，并在参数生命周期结束时（构造函数结束时）销毁。

标准明确指出：

构造函数构造函数初始化程序 (12.6.2) 中引用成员的临时绑定将持续存在，直到构造函数退出。

Answer 3

§12.2/5 说“第二个上下文[当临时的生命周期
被扩展]是指将引用绑定到临时对象。”
从字面上看，这清楚地表明寿命应该延长
你的情况；你的 B::a 肯定绑定到一个临时变量。 （参考
绑定到一个对象，并且我看不到它可能存在的任何其他对象
）然而，这是非常糟糕的措辞；我确信那是什么
意思是“第二个上下文是当临时用于
初始化一个引用”，并且延长的生命周期对应于
使用右值表达式创建的引用初始化的值
临时的，而不是以后可能的任何其他参考文献
被绑定到对象上。就目前而言，措辞需要一些东西
这根本无法实现：考虑：

void f(A const& a)
{
    static A const& localA = a;
}

用以下方式调用：

f(A());

编译器应该将 A() 放在哪里（假设它通常看不到
f() 的代码，并且不知道何时的本地静态
生成呼叫）？

事实上，我认为这值得 DR。

我可能会补充一点，有文字强烈表明我的
意图的解释是正确的。想象一下你有一秒钟
B 的构造函数：

B::B() : a(A()) {}

在这种情况下，B::a 将直接使用临时变量进行初始化；这
即使按照我的解释，这个临时的生命周期也应该延长。
然而，该标准对这种情况做出了特定的例外；这样一个
临时仅持续到构造函数退出为止（这又会
给你留下一个悬而未决的参考）。这个例外提供了一个非常
强烈表明该标准的作者无意
类中的成员引用可延长任何临时对象的生命周期
他们有义务；再次，动机是可实施性。想象
而不是

B b((A()));

你写的：

B* b = new B(A());

编译器应该将临时 A() 放置在哪里，以便它的生命周期
是动态分配的B吗？

Answer 4

您的示例不执行嵌套生命周期扩展

在构造函数中

B(const A & a_) : a(a_) { std::cout << " B()" << std::endl; }

这里的 a_ （为便于说明而重命名）不是临时的。表达式是否是临时的是表达式的语法属性，并且 id-expression 永远不是临时的。所以这里不会发生寿命延长。

这是一种会发生生命周期延长的情况：

B() : a(A()) { std::cout << " B()" << std::endl; }

但是，由于引用是在构造函数初始化程序中初始化的，因此生命周期只会延长到函数结束为止。每 [class.temporary]p5：

到构造函数的构造函数初始化程序 (12.6.2) 中的引用成员的临时绑定将持续存在，直到构造函数退出。

在对构造函数的调用中

B b((A())); //extra braces are needed!

，我们将引用绑定到临时对象。 [class.temporary]p5 说：

在函数调用 (5.2.2) 中临时绑定到引用参数将持续存在，直到包含调用的完整表达式完成为止。

因此 A 临时变量在语句结束时被销毁。这发生在块末尾的 B 变量被销毁之前，解释了您的日志输出。

其他情况确实执行嵌套生命周期扩展

聚合变量初始化

具有引用成员的结构的聚合初始化可以延长生命周期：

struct X {
  const A &a;
};
X x = { A() };

在这种情况下，A 临时文件直接绑定到引用，因此临时文件的生命周期被延长到xa的生​​命周期，这与x的生​​命周期相同。 （警告：直到最近，很少有编译器能做到这一点）。

聚合临时初始化

在 C++11 中，您可以使用聚合初始化来初始化临时变量，从而获得递归生命周期扩展：

struct A {
   A()  { std::cout << " A()" << std::endl; }
   ~A() { std::cout << "~A()" << std::endl; }
};

struct B {
   const A &a;
   ~B() { std::cout << "~B()" << std::endl; }
};

int main() {
  const B &b = B { A() };
  std::cout << "-----" << std::endl;
}

使用 trunk Clang 或 g++，这会产生以下输出：

 A()
-----
~B()
~A()

请注意，< code>A 临时和 B 临时是生命周期延长的。因为 A 临时对象的构造首先完成，所以它最后被销毁。

在 std::initializer_list 初始化中，

C++11 的 std::initializer_list 执行生命周期扩展，就好像通过绑定对底层数组的引用。因此，我们可以使用 std::initializer_list 执行嵌套生命周期扩展。然而，编译器错误在这个领域很常见：

struct C {
  std::initializer_list<B> b;
  ~C() { std::cout << "~C()" << std::endl; }
};
int main() {
  const C &c = C{ { { A() }, { A() } } };
  std::cout << "-----" << std::endl;
}

使用 Clang trunk 生成：

 A()
 A()
-----
~C()
~B()
~B()
~A()
~A()

和使用 g++ trunk：

 A()
 A()
~A()
~A()
-----
~C()
~B()
~B() 

这些都是错误的；正确的输出是：

 A()
 A()
-----
~C()
~B()
~A()
~B()
~A()

Answer 5

在第一次运行中，对象按照它们被推入堆栈的顺序被销毁 ->即push A、push B、pop B、pop A。

在第二次运行中，A 的生命周期随着b 的构造而结束。因此，它创建了 A，从 A 创建了 B，A 的生命周期结束，因此它被销毁，然后 B 被销毁。有道理...

Answer 6

我不了解标准，但可以讨论我在之前几个问题中看到的一些事实。

第一个输出保持原样，原因显而易见，a 和 b 位于同一范围内。另外，a 在 b 之后被销毁，因为它是在 b 之前构造的。

我认为您应该对第二个输出更感兴趣。在开始之前，我们应该注意以下类型的对象创建（独立临时对象）：

{
  A();
}

仅持续到下一个 ; 并且不适用于它周围的块。 演示。在第二种情况下，当您

B b((A()));

这样做时，一旦 B() 对象创建完成，A() 就会被销毁。由于 const 引用可以绑定到临时引用，因此不会出现编译错误。然而，如果您尝试访问 B::a ，它肯定会导致逻辑错误，它现在绑定到已经超出范围的变量。

Answer 7

§12.2/5 说

在函数调用 (5.2.2) 中临时绑定到引用参数将持续存在，直到包含调用的完整表达式完成为止。

真的，剪得很漂亮，晒干了。