谁复制函数的返回值？答案

【问题标题】：Who copies the return value of a function?谁复制函数的返回值？
【发布时间】：2013-06-29 13:37:28
【问题描述】：

是调用者还是被调用者复制或移动函数的返回值？比如我想实现一个队列的pop()函数，像这样

template <typename T> 
class queue
{
    std::deque<T> d;
public:
    // ... //
    T pop()
    {
        // Creates a variable whose destructor removes the first
        // element of the queue if no exception is thrown. 
        auto guard = ScopeSuccessGuard( [=]{ d.pop_front(); } );
        return d.front();
    }
}

我的作用域守卫的析构函数是在复制前面的元素后调用的吗？

编辑：后续问题：行吗

auto item = q.pop();

现在是异常安全的吗？

【问题讨论】：

是的，具有自动存储持续时间的变量（例如您的guardhere）在返回指令（及其构造/副本）后被销毁。您可以查看标准部分 6.6 和 6.7 中的跳转指令和声明。也许你可以更容易地尝试使用虚拟对象在销毁时打印一些东西^^

标签： c++ c++11 copying scopeguard

【解决方案1】：

返回值在局部变量超出范围之前被复制出来。复制/移动可能是到临时位置（堆栈或寄存器）或直接到调用者自己的缓冲区或首选寄存器 - 这是一个优化/内联问题。

在涉及临时位置的情况下，编译器必须在调用者和被调用者之间安排一些工作分工，并且对于返回值（当然还有函数参数）有许多操作系统和二进制对象/可执行格式特定的约定，这样使用一个编译器编译的库/对象通常仍可以与另一个编译器一起使用。

行吗...

auto item = q.pop();

...保持异常安全？

假设pop_front() 不能throw，有趣的情况是返回一个临时位置，在函数返回后再次将值从该位置复制到调用者缓冲区。在我看来，您没有对此进行充分的保护。省略（被调用者直接在调用者的结果缓冲区/寄存器中构造返回值）是允许的，但不是必需的。

为了探索这一点，我编写了以下代码：

#include <iostream>

struct X
{
    X() { std::cout << "X::X(this " << (void*)this << ")\n"; }
    X(const X& rhs) { std::cout << "X::X(const X&, " << (void*)&rhs
                                << ", this " << (void*)this << ")\n"; }
    ~X() { std::cout << "X::~X(this " << (void*)this << ")\n"; }

    X& operator=(const X& rhs)
    { std::cout << "X::operator=(const X& " << (void*)&rhs
                << ", this " << (void*)this << ")\n"; return *this; }
};

struct Y
{
    Y() { std::cout << "Y::Y(this " << (void*)this << ")\n"; }
    ~Y() { std::cout << "Y::~Y(this " << (void*)this << ")\n"; }
};

X f()
{
   Y y;
   std::cout << "f() creating an X...\n";
   X x;
   std::cout << "f() return x...\n";
   return x;
};

int main()
{
    std::cout << "creating X in main...\n";
    X x;
    std::cout << "x = f(); main...\n";
    x = f();
}

使用g++ -fno-elide-constructors 编译，我的输出（带有额外的 cmets）是：

creating X in main...
X::X(this 0x22cd50)
x = f(); main...
Y::Y(this 0x22cc90)
f() creating an X...
X::X(this 0x22cc80)
f() return x...
X::X(const X&, 0x22cc80, this 0x22cd40)   // copy-construct temporary
X::~X(this 0x22cc80)   // f-local x leaves scope
Y::~Y(this 0x22cc90)
X::operator=(const X& 0x22cd40, this 0x22cd50)  // from temporary to main's x
X::~X(this 0x22cd40)
X::~X(this 0x22cd50)

显然，分配发生在f() 离开作用域之后：任何异常都将在你的作用域保护（这里用 Y 表示）被销毁之后。

如果 main 包含 X x = f(); 或 X x(f());，则会发生同样的事情，除非它是在销毁 f()-local 变量后调用的复制构造函数。

（我很欣赏一个编译器的行为有时不能很好地推断标准是否需要某些东西才能工作，但反过来说它更可靠：当它不工作时，编译器坏了 - 哪个比较少见——或者标准不需要它。在这里，编译器行为只是用来增加我对标准要求的印象的轶事权重。）

好奇的细节：并不是说拥有只能以一种方式调用的代码通常很有用，但可能安全的东西是const X& x = f();，作为const 参考延长了临时的生命周期，但我无法说服自己标准要求将临时生命周期延长的临时函数复制到没有任何额外副本的临时函数中；对于它的价值 - 它在我的程序中“工作”，有趣的是，如果删除返回值，临时占用相同的堆栈位置，这表明 f() 代码被有效地编译，具有删除的能力，-f-no-elide-constructors 选项是与其说是禁用优化，不如说是为了增加悲观情绪：在调用函数之前为临时保留额外的堆栈空间，然后添加额外的代码以从中复制并销毁临时，然后重新调整堆栈指针....

【讨论】：

【解决方案2】：

返回值的副本由被调用者完成，并且必须在调用析构函数之前进行，否则您将无法返回本地构造变量的值/内容。

这是标准中的相关部分：第 12.4 节，第 11 点（析构函数）

析构函数被隐式调用

用于在创建对象的块退出 (6.7) 时具有自动存储持续时间 (3.7.3) 的构造对象

我试图找到一个地方，上面写着“回归发生在破坏之前”，但它并没有像我想要的那样清楚地说明[除非我遗漏了什么]。

【讨论】：