返回对绑定到临时的引用参数的引用时悬空引用

Question

这个问题是指 Howard Hinnant 对问题Guaranteed elision and chained function calls 的回答。

在他的回答的底部，他说：

请注意，在此最新设计中，如果您的客户曾经这样做：

X&& x = a + b + c;

那么 x 是一个悬空引用（这就是 std::string 不这样做的原因）。

cppreference.com 上的文章“引用初始化”的“临时对象的生命周期”段落列出了绑定到引用的临时对象生命周期规则的例外情况。一个是：

“函数调用中引用参数的临时绑定一直存在到包含该函数调用的完整表达式的末尾：如果函数返回的引用比完整表达式的寿命长，则它成为悬空引用。”

我认为它的意思是“如果函数返回一个引用到引用参数绑定到的临时对象”，而不仅仅是其他一些引用。因此，我认为这就是解释 Howard Hinnant 上述陈述的规则。

以下示例基于我所指问题中给出的示例：

struct X
{
    int _x;
    X() : _x(0) {}
    X(int x) : _x(x) {}
    X(X const& other) : _x(other._x) {}
    X(X&& other) noexcept : _x(other._x) { other._x = 0; std::cout << "Move from " << &other << " to " << this << std::endl; }
    X& operator+=(const X& other) { _x += other._x; return *this; }

    friend X operator+(X const& lhs, X const& rhs)
    {
        std::cout << "X const& lhs: " << &lhs << std::endl;
        X temp = lhs;
        temp += rhs;
        return temp;
    }

    friend X&& operator+(X&& lhs, X const& rhs)
    {
        std::cout << "X&& lhs: " << &lhs << std::endl;
        lhs += rhs;
        return std::move(lhs);
    }
};

int anotherFunc(int a)
{
    int bigArray[3000]{};
    std::cout << "ignore:" << &bigArray << std::endl;
    int b = a * a;
    std::cout << "int b: " << &b << std::endl;
    return 2 * b;
}

int main()
{
    X a(1), b(2), c(3), d(4);
    X&& sum = a + b + c + d;
    std::cout << "X&& sum: " << &sum << std::endl;
    anotherFunc(15);
    std::cout << "sum._x: " << sum._x << std::endl;

    return 0;
}

打印出来

X const& lhs: 000000907DAFF8B4
Move from 000000907DAFF794 to 000000907DAFFA14
X&& lhs: 000000907DAFFA14
X&& lhs: 000000907DAFFA14
X&& sum: 000000907DAFFA14
ignore:000000907DAFC360
int b: 000000907DAFF254
sum._x: 10

使用 MSVC 编译时；以及使用 gcc 或 clang 编译时的类似输出。

sum 在这里应该是一个悬空引用。尽管如此，仍在打印正确的值“10”。它甚至可以在sum 的引用初始化和通过所述引用进行访问之间将一个大数组推入堆栈时工作。用于 sum 引用的临时对象的内存不会被重用，并且总是分配到其他地方（与以下函数调用的堆栈帧相关），无论下一个堆栈帧有多大或多小。

为什么我测试过的每个编译器都会保留X&& operator+(X&& lhs, X const& rhs) 本地的临时对象，即使根据cppreference.com 的规则，sum 应该是一个悬空引用。或者，更准确地说：尽管访问悬空引用是未定义的行为，但为什么每个编译器都以这种方式实现它？

Answer 1

我喜欢在这种情况下保留一个示例class A。 A 的完整定义有点冗长，无法在此处列出，但完整包含在 at this link 中。

简而言之，A 保留一个state 和一个status，而status 可以是这些枚举之一：

    destructed             = -4,
    self_move_assigned     = -3,
    move_assigned_from     = -2,
    move_constructed_from  = -1,
    constructed_specified  =  0

即特殊成员相应地设置状态。例如~A() 看起来像这样：

~A()
{
    assert(is_valid());
    --count;
    state_ = randomize();
    status_ = destructed;
}

还有一个流式操作符可以打印出这个类。

语言律师免责声明： 打印出被破坏的A 是未定义的行为，任何事情都可能发生。话虽如此，当在关闭优化的情况下编译实验时，您通常会得到预期的结果。

对我来说，在-O0 使用clang，这样：

#include "A.h"
#include <iostream>

int
main()
{
    A a{1};
    A b{2};
    A c{3};
    A&& x = a + b + c;
    std::cout << x << '\n';
}

输出：

destructed: -1002199219

将行改为：

    A x = a + b + c;

结果：

6