auto&& 如何延长临时对象的生命周期？

Question

下面的代码说明了我的担忧：

#include <iostream>


struct O
{
    ~O()
    {
        std::cout << "~O()\n";
    }
};

struct wrapper
{
    O const& val;

    ~wrapper()
    {
        std::cout << "~wrapper()\n";
    }
};

struct wrapperEx // with explicit ctor
{
    O const& val;

    explicit wrapperEx(O const& val)
      : val(val)
    {}

    ~wrapperEx()
    {
        std::cout << "~wrapperEx()\n";
    }
};

template<class T>
T&& f(T&& t)
{
    return std::forward<T>(t);
}


int main()
{
    std::cout << "case 1-----------\n";
    {
        auto&& a = wrapper{O()};
        std::cout << "end-scope\n";
    }
    std::cout << "case 2-----------\n";
    {
        auto a = wrapper{O()};
        std::cout << "end-scope\n";
    }
    std::cout << "case 3-----------\n";
    {
        auto&& a = wrapper{f(O())};
        std::cout << "end-scope\n";
    }
    std::cout << "case Ex-----------\n";
    {
        auto&& a = wrapperEx{O()};
        std::cout << "end-scope\n";
    }
    return 0;
}

现场观看here。

据说auto&&会延长临时对象的生命周期，但是我找不到这条规则的标准词，至少在N3690中找不到。

最相关的可能是关于临时对象的第 12.2.5 节，但不完全是我想要的。

那么，auto&& 生命周期延长规则是否适用于所有表达式中涉及的临时对象，还是仅适用于最终结果？

更具体地说，a.val 在我们到达案例 1 的范围结束之前是否保证有效（非悬空）？

编辑： 我更新了示例以显示更多案例（3 和 Ex）。

您会看到，只有在情况 1 中，O 的生命周期才会延长。

Answer 1

与const 的引用方式相同：

const auto& a = wrapper{O()};

或

const wrapper& a = wrapper{O()};

也可以

wrapper&& a = wrapper{O()};

更具体地说，a.val 在我们到达案例 1 的范围结束之前是否保证有效（非悬空）？

是的。

auto 这里（几乎）没有什么特别重要的。它只是编译器推断的正确类型 (wrapper) 的 占位符。重点是临时对象绑定到一个引用。

有关更多详细信息，请参阅我引用的A Candidate For the “Most Important const”：

通常，临时对象只会持续到它出现的完整表达式的末尾。但是，C++ 故意指定将临时对象绑定到堆栈上对 const 的引用会将临时对象的生命周期延长到引用本身的生命周期

这篇文章是关于 C++ 03 但参数仍然有效：临时可以绑定到对const 的引用（但不能绑定到对非const 的引用）。在 C++ 11 中，临时变量也可以绑定到右值引用。在这两种情况下，临时对象的生命周期都会延长到引用的生命周期。

C++11 标准的相关部分正是 OP 中提到的那些，即 12.2 p4 和 p5：

4 - 临时对象在两种情况下被销毁 与完整表达式的结尾不同的点。第一个上下文 是[...]

5 - 第二个上下文是引用绑定到临时的。 [...]

（这些行后面的项目符号中有一些例外。）

更新：（根据 texasbruce 的评论。）

案例 2 中的 O 寿命短的原因是我们有 auto a = wrapper{O()};（请参阅，这里没有 &），然后临时值 不 绑定到参考。实际上，使用编译器生成的复制构造函数将临时复制到a。因此，临时变量的生命周期没有扩展，并且在它出现的完整表达式结束时死亡。

在这个特定示例中存在危险，因为wrapper::val 是一个引用。编译器生成的wrapper 的复制构造函数会将a.val 绑定到临时的val 成员绑定到的同一对象。该对象也是一个临时对象，但类型为O。然后，当后者暂时死亡时，我们会在屏幕上看到 ~O() 和 a.val 悬垂！

对比案例 2：

std::cout << "case 3-----------\n";
{
    O o;
    auto a = wrapper{o};
    std::cout << "end-scope\n";
}

输出是（使用 gcc 编译时使用选项 -fno-elide-constructors）

case 3-----------
~wrapper()
end-scope
~wrapper()
~O()

现在临时wrapper 的val 成员绑定到o。请注意，o 不是临时的。正如我所说，a 是 wrapper 临时的副本，a.val 也绑定到 o。在作用域结束之前，临时的wrapper 消失了，我们在屏幕上看到了第一个~wrapper()。

然后作用域结束，我们得到end-scope。现在，a 和o 必须按照构造的相反顺序销毁，因此当a 死亡时我们会看到~wrapper()，而在o 的时间最后是~O()。这表明a.val 没有悬空。

（最后一句话：我使用-fno-elide-constructors 来防止与复制构造相关的优化，这会使这里的讨论复杂化，但这是另一个story。）