c++ - 谁复制函数的返回值？

Question

是调用者还是被调用者复制或移动函数的返回值？比如我要实现一个队列的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();

现在是强异常安全的吗？

Answer 1

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

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

Would the line...

auto item = q.pop();

...be strongly exception safe?

假设 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 编译，我的输出(带有额外注释)是:

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() 局部变量之后。

(我很欣赏一个编译器的行为有时不能很好地作为标准是否需要某些东西才能工作的推理基础，但反过来要可靠得多:当它不工作时要么编译器坏了 - 这相对罕见 - 或者标准不需要它。在这里，编译器行为只是用来增加我对标准要求的印象的轶事权重。)

好奇的细节:并不是说代码只能以一种方式调用通常是有用的，但是可能是安全的是 const X& x = f() ;，因为 const 引用延长了临时的生命周期，但我无法说服自己标准要求拥有生命周期延长的临时临时复制到的函数没有任何额外的拷贝；对于它的值(value) - 它在我的程序中“起作用”，有趣的是，如果省略返回值，临时占用相同的堆栈位置，这表明 f() 代码被有效编译并具有省略的能力并且 -f-no-elide-constructors 选项与其说是禁用优化，不如说是添加悲观:在调用函数之前为临时保留额外的堆栈空间，然后添加额外的代码从那里复制并破坏临时的，然后重新调整堆栈指针....