为什么按值参数从 NRVO 中排除？

Question

想象一下：

S f(S a) {
  return a;
}

为什么不允许别名a和返回值槽？

S s = f(t);
S s = t; // can't generally transform it to this :(

如果S 的复制构造函数有副作用，规范不允许这种转换。相反，它至少需要两份副本（一份从t 到a，一份从a 到返回值，另一份从返回值到s，只有最后一个可以省略。请注意，我在上面写了= t 以表示将t 复制到f 的a 的事实，这是在移动/复制构造函数存在副作用的情况下仍然是强制性的唯一副本。

这是为什么呢？

Answer 1

这就是为什么复制省略对参数没有意义。它实际上是关于在编译器级别实现概念的。

复制省略的工作原理是在原地构造返回值。该值不会被复制出来；它是直接在其预期目的地创建的。为预期输出提供空间的是调用者，因此最终是调用者为省略提供了可能性。

为了删除副本，函数内部需要做的就是在调用者提供的位置构造输出。如果函数可以做到这一点，你会得到复制省略。如果函数不能，那么它将使用一个或多个临时变量来存储中间结果，然后将其复制/移动到调用者提供的位置。它仍然是就地构造的，但输出的构造是通过复制发生的。

因此，特定函数之外的世界不必知道或关心函数是否会省略。具体来说，函数的调用者不必知道函数是如何实现的。它没有做任何不同的事情。是函数本身决定是否可以省略。

值参数的存储也由调用者提供。当您调用f(t) 时，调用者会创建t 的副本并将其传递给f。同样，如果S 可以从int 隐式构造，那么f(5) 将从5 构造S 并将其传递给f。

这一切都是由调用者完成的。被调用者不知道也不关心它是变量还是临时变量；它只是给了一个堆栈内存（或寄存器或其他任何东西）。

现在请记住：复制省略有效，因为被调用的函数将变量直接构造到输出位置。因此，如果您试图忽略值参数的返回，那么值参数的存储也必须是输出存储本身。但请记住：调用者为参数和输出提供存储。因此，为了省略输出副本，调用者必须将参数直接构造到输出中。

为此，现在调用者需要知道它正在调用的函数将忽略返回值，因为如果参数将被返回，它只能将参数直接粘贴到输出中。这在编译器级别通常是不可能的，因为调用者不一定具有函数的实现。如果函数是内联的，那么它也许可以工作。但否则没有。

因此，C++ 委员会并没有考虑到这种可能性。

Answer 2

据我了解，该限制的基本原理是调用约定可能（并且在许多情况下）要求函数的参数和返回对象位于不同的位置（内存或寄存器）。考虑以下修改示例：

X foo();
X bar( X a ) 
{ 
   return a;
}
int main() {
   X x = bar( foo() );
}

理论上整个副本集是foo（$tmp1）中的return语句，bar的参数a，bar（$tmp2）和x中的return语句987654330@。编译器可以通过在a 的位置创建$tmp1 和在x 的位置创建$tmp2 来省略四个对象中的两个。当编译器处理main 时，它可以注意到foo 的返回值是bar 的参数并且可以使它们重合，此时它不可能知道（没有内联）@ 的参数和返回987654338@ 是同一个对象，它必须符合调用约定，所以它会将$tmp1 放在bar 的参数位置。

同时它知道$tmp2的目的只是创建x，所以可以将两者放在同一个地址。在bar 内部，没有什么可以做的：参数a 位于第一个参数的位置，根据调用约定，$tmp2 必须根据调用约定定位，（在不同位置的一般情况，认为可以将示例扩展为带有更多参数的bar，其中只有一个用作返回语句。

现在，如果编译器执行内联，它可以检测到如果函数没有内联则需要的额外副本实际上是不需要的，并且它有机会省略它。如果标准允许省略该特定副本，那么相同的代码将具有不同的行为，具体取决于函数是否内联。

Answer 3

David Rodríguez - dribeas 对我的问题的回答 'How to allow copy elision construction for C++ classes' 给了我以下想法。诀窍是使用 lambdas 将评估延迟到函数体内：

#include <iostream>

struct S
{
  S() {}
  S(const S&) { std::cout << "Copy" << std::endl; }
  S(S&&) { std::cout << "Move" << std::endl; }
};

S f1(S a) {
  return a;
}

S f2(const S& a) {
  return a;
}

#define DELAY(x) [&]{ return x; }

template <class F>
S f3(const F& a) {
  return a();
}

int main()
{
  S t;
  std::cout << "Without delay:" << std::endl;
  S s1 = f1(t);
  std::cout << "With delay:" << std::endl;
  S s2 = f3(DELAY(t));
  std::cout << "Without delay pass by ref:" << std::endl;
  S s3 = f2(t);
  std::cout << "Without delay pass by ref (temporary) (should have 0 copies, will get 1):" << std::endl;
  S s4 = f2(S());
  std::cout << "With delay (temporary) (no copies, best):" << std::endl;
  S s5 = f3(DELAY(S()));
}

这在ideone GCC 4.5.1 上输出：

刻不容缓：
复制
复制
有延迟：
复制

现在这很好，但可以建议 DELAY 版本就像通过 const 引用传递一样，如下所示：

无延迟通过 ref:
复制

但是如果我们通过 const 引用传递一个临时的，我们仍然会得到一个副本：

无延迟通过 ref（临时）（应该有 0 个副本，将得到 1 个）：
复制

延迟版本省略副本的地方：

延迟（临时）（最好不要复制）：

如您所见，这会忽略临时案例中的所有副本。

延迟版本在非临时情况下生成一份副本，在临时情况下不生成副本。除了 lambdas，我不知道有什么方法可以实现这一点，但如果有的话我会很感兴趣。

Answer 4

从 t 到 a 省略副本是不合理的。该参数被声明为可变的，因此复制完成，因为它预计会在函数中被修改。

从 a 到返回值我看不到任何复制的理由。也许这是某种疏忽？按值参数感觉就像函数体内的本地人......我看不出有什么区别。

Answer 5

我觉得，因为替代方案总是可用进行优化：

S& f(S& a) { return a; }  // pass & return by reference
^^^  ^^^

如果 f() 的编码如您的示例中所述，那么假设 有意复制 或预期副作用是完全可以的；否则为什么不通过参考选择通行证/退货？

假设如果 NRVO 适用（如您所问），那么 S f(S) 和 S& f(S&) 之间没有区别！

NRVO 在operator +() (example) 之类的情况下发挥作用，因为没有值得替代的选择。

一个支持方面，以下所有功能都有不同的复制行为：

S& f(S& a) { return a; }  // 0 copy
S f(S& a) { return a; } // 1 copy
S f(S a) { A a1; return (...)? a : a1; }  // 2 copies

在第 3 个 sn-p 中，如果在编译时知道 (...) 是 false，那么编译器只会生成 1 个副本。
这意味着，当有一个简单的替代方案可用时，编译器故意不执行优化。

Answer 6

我认为问题在于，如果复制构造函数做了某事，那么编译器必须做那件事可预测的次数。例如，如果您有一个类在每次复制时都会增加一个计数器，并且有一种访问该计数器的方法，那么符合标准的编译器必须执行该操作明确定义的次数（否则，如何编写单元测试？）

现在，实际编写这样的类可能是个坏主意，但编译器的工作不是弄清楚这一点，而只是确保输出正确且一致。