按值传递vs按右值引用传递

我何时应该将函数声明为：

void foo(Widget w);

相对于

void foo(Widget&& w);？

假设这是唯一的重载（例如，我选择一个或另一个，而不是两个，也没有其他重载）。不涉及模板。假设该功能foo需要拥有Widget（例如const Widget&，这不是本讨论的一部分）。在这些情况范围之外，我对任何答案都不感兴趣。有关为什么这些约束是问题的一部分，请参见文章末尾的附录。

我和我的同事可以想到的主要区别是，右值引用参数迫使您对副本明确。调用方负责制作显式副本，然后在std::move需要复制时将其传递给它。在按值传递的情况下，副本的成本被隐藏：

    //If foo is a pass by value function, calling + making a copy:
    Widget x{};
    foo(x); //Implicit copy
    //Not shown: continues to use x locally

    //If foo is a pass by rvalue reference function, calling + making a copy:
    Widget x{};
    //foo(x); //This would be a compiler error
    auto copy = x; //Explicit copy
    foo(std::move(copy));
    //Not shown: continues to use x locally

除了那个区别。除了强迫人们明确地复制和更改调用函数时获得多少语法糖外，这些还有什么不同？他们对界面有何不同看法？它们是彼此相比效率更高还是更低？

我和我的同事已经想到的其他事项：

• 右值引用参数表示您可以移动参数，但不强制使用该参数。之后，您在调用站点传递的参数可能会保持其原始状态。该函数也有可能在不调用move构造函数的情况下吃掉/更改了参数，但假定由于它是一个右值引用，因此调用者放弃了控件。通过价值传递，如果您进入其中，则必须假设发生了移动；别无选择。
• 假设没有省略，通过rvalue传递消除了单个move构造函数调用。
• 编译器有更好的机会按值传递副本/移动。谁能证实这一说法？最好有一个指向gcc.godbolt.org的链接，该链接显示了来自gcc / clang的优化生成的代码，而不是标准中的一行。我试图证明这一点可能无法成功隔离行为： https //godbolt.org/g/4yomtt

附录： 为什么我要限制这么多的问题？

• 没有重载-如果还有其他重载，则将讨论按值传递与一组重载（包括const引用和rvalue引用）的重载的讨论，此时重载的集合显然更有效并且更成功。这是众所周知的，因此并不有趣。
• 没有模板-我对转发引用如何适合图片不感兴趣。如果您有转发参考，则无论如何都要调用std :: forward。具有转发参考的目标是在您收到邮件时传递它们。副本无关紧要，因为您只是传递了一个左值。这是众所周知的，并不有趣。
• foo需要拥有Widget（aka no const Widget&）的所有权-我们不是在谈论只读功能。如果该函数是只读的，或者不需要拥有或延长的寿命Widget，那么答案就变成了const Widget&，这又是众所周知的，而且没有意思。我也向您介绍为什么我们不想谈论重载。

rvalue参考参数强制您对副本明确。

是的，通过右值引用很重要。

右值引用参数表示您可以移动参数，但不强制使用该参数。

是的，按值传递很有意义。

但这也给传递值提供了处理异常保证的机会：如果foo抛出异常，widget则不必消耗值。

对于仅移动类型（如std::unique_ptr），按值传递似乎是常态（主要是针对您的第二点，而第一点始终不适用）。

编辑：标准库与我之前的句子相矛盾，其中一个shared_ptr的构造函数采用std::unique_ptr<T, D>&&。

对于同时具有复制/移动（如std::shared_ptr）的类型，我们可以选择与先前类型的一致性，也可以选择在复制时强制显式。

除非您想保证没有多余的副本，否则我将使用值传递来保持一致性。

除非您想要保证和/或立即下沉，否则我将使用传递右值。

对于现有的代码库，我会保持一致性。

关于接口与复制的右值用法怎么说？rvalue向调用者暗示该函数既要拥有该值，也无意让调用者知道其所做的任何更改。考虑以下内容（我知道您在示例中没有提到左值引用，但请耐心等待）：

//Hello. I want my own local copy of your Widget that I will manipulate,
//but I don't want my changes to affect the one you have. I may or may not
//hold onto it for later, but that's none of your business.
void foo(Widget w);

//Hello. I want to take your Widget and play with it. It may be in a
//different state than when you gave it to me, but it'll still be yours
//when I'm finished. Trust me!
void foo(Widget& w);

//Hello. Can I see that Widget of yours? I don't want to mess with it;
//I just want to check something out on it. Read that one value from it,
//or observe what state it's in. I won't touch it and I won't keep it.
void foo(const Widget& w);

//Hello. Ooh, I like that Widget you have. You're not going to use it
//anymore, are you? Please just give it to me. Thank you! It's my
//responsibility now, so don't worry about it anymore, m'kay?
void foo(Widget&& w);

另一种查看方式：

//Here, let me buy you a new car just like mine. I don't care if you wreck
//it or give it a new paint job; you have yours and I have mine.
void foo(Car c);

//Here are the keys to my car. I understand that it may come back...
//not quite the same... as I lent it to you, but I'm okay with that.
void foo(Car& c);

//Here are the keys to my car as long as you promise to not give it a
//paint job or anything like that
void foo(const Car& c);

//I don't need my car anymore, so I'm signing the title over to you now.
//Happy birthday!
void foo(Car&& c);

现在，如果小部件必须保持唯一性（例如GTK中的实际小部件必须这样做），则第一个选项将不起作用。第二个，第三个和第四个选项很有意义，因为仍然只有一种真实的数据表示形式。无论如何，当我在代码中看到它们时，这些语义就是对我说的。

现在，关于效率：这取决于。如果Widget有一个指向数据成员的指针，那么右值引用可以节省大量时间，该数据成员的指向内容可能会很大（想一个数组）。由于呼叫者使用了右值，所以他们说他们不再关心自己给您的东西了。因此，如果您想将调用方窗口小部件的内容移动到您的窗口小部件中，只需获取其指针即可。无需精心复制指针指向的数据结构中的每个元素。这可以大大提高速度（再次考虑数组）。但是，如果Widget类没有任何此类东西，那么这种好处是无处可寻的。

希望能达到您的要求；如果没有，我也许可以扩大/澄清。

除非该类型是仅移动类型，否则您通常可以选择按引用传递const，并且使其成为“不是讨论的一部分”似乎是任意的，但我会尝试。

我认为选择部分取决于foo参数的作用。

该功能需要本地副本

假设Widget是一个迭代器，并且您想实现自己的std::next功能。next需要自己的副本以前进然后返回。在这种情况下，您的选择类似于：

Widget next(Widget it, int n = 1){
    std::advance(it, n);
    return it;
}

与

Widget next(Widget&& it, int n = 1){
    std::advance(it, n);
    return std::move(it);
}

我认为按值计算在这里更好。从签名中您可以看到它正在复印。如果呼叫者想要避免复制，则可以执行std::move并确保将变量从中移出，但是如果愿意，他们仍然可以传递左值。使用传递右值引用，调用者无法保证已将变量移出。

移动分配到副本

假设您有一堂课WidgetHolder：

class WidgetHolder {
    Widget widget;
   //...
};

并且您需要实现一个setWidget成员函数。我将假设您已经有一个需要引用const的重载：

WidgetHolder::setWidget(const Widget& w) {
    widget = w;
}

但是在评估效果后，您决定需要针对r值进行优化。您可以选择替换为：

WidgetHolder::setWidget(Widget w) {
    widget = std::move(w);
}

或超载：

WidgetHolder::setWidget(Widget&& widget) {
    widget = std::move(w);
}

这一点比较棘手。吸引人的是选择按值传递，因为它同时接受rvalue和lvalues，因此您不需要两个重载。但是，它是无条件复制的，因此您无法利用成员变量中的任何现有容量。按引用传递给const和按r值传递引用重载使用赋值而不获取副本，这可能会更快

移动构造副本

现在，假设您正在编写的构造函数WidgetHolder，就像以前一样，已经实现了采用对const的引用的构造函数：

WidgetHolder::WidgetHolder(const Widget& w) : widget(w) {
}

和之前一样，您要测量性能并决定需要针对右值进行优化。您可以选择替换为：

WidgetHolder::WidgetHolder(Widget w) : widget(std::move(w)) {
}

或超载：

WidgetHolder::WidgetHolder(Widget&& w) : widget(std:move(w)) {
}

在这种情况下，成员变量不能具有任何现有容量，因为这是构造函数。您正在移动构造一个副本。而且，构造函数通常会使用许多参数，因此编写所有不同的重载排列以优化r值引用可能会很痛苦。因此，在这种情况下，最好使用按值传递，尤其是在构造函数采用许多此类参数的情况下。

通过 unique_ptr

鉴于unique_ptr效率如此低廉，而且搬迁没有任何能力，因此对效率的关注并不那么重要。更重要的是表达力和正确性。关于如何通过unique_ptr 这里有很好的讨论。

当您通过右值引用对象时，其生存期会变得很复杂。如果被调用方没有移出参数，则参数的销毁将延迟。我认为这在两种情况下都很有趣。

首先，您有一个RAII课程

void fn(RAII &&);

RAII x{underlying_resource};
fn(std::move(x));
// later in the code
RAII y{underlying_resource};

初始化时y，如果资源没有移出右值引用，x则仍可以保留该资源fn。在按值传递代码中，我们知道x将其移出并fn释放x。在这种情况下，可能需要按值传递，并且复制构造函数可能会被删除，因此您不必担心意外复制。

其次，如果参数是一个大对象，并且函数没有移动，则矢量数据的生存期要比按值传递的情况长。

vector<B> fn1(vector<A> &&x);
vector<C> fn2(vector<B> &&x);

vector<A> va;  // large vector
vector<B> vb = fn1(std::move(va));
vector<C> vc = fn2(std::move(vb));

在上面的示例中，如果fn1和fn2不移出x，则最终所有矢量中的所有数据仍然有效。如果改为按值传递，则仅最后一个向量的数据仍然有效（假设向量move构造函数清除了源向量）。

其他答案中未提及的一个问题是异常安全性。

通常，如果函数引发异常，则理想情况下，我们希望具有较强的异常保证，这意味着调用除了引发异常外没有其他作用。如果按值传递使用move构造函数，那么这种效果本质上是不可避免的。因此，在某些情况下，右值引用参数可能更好。（当然，在很多情况下都无法实现强异常保证，以及在两种情况下都不能提供无掷保证的情况。因此，这在100％的情况下都无关紧要。但这是相关的有时。）

在按值和按值引用之间进行选择（没有其他重载）没有意义。

通过值传递，实际参数可以是左值表达式。

使用rvalue-ref传递时，实际参数必须为rvalue。

如果函数存储的是参数的副本，那么明智的选择是在按值传递和一组将常量传递给const和传递右值引用的重载之间。对于右值表达式作为实际参数，一组重载可以避免一个步骤。微观优化是否值得增加复杂性和类型决定，这是一个工程上的直觉。

一个显着的区别是，如果您转到值传递函数：

void foo(Widget w);
foo(std::move(copy));

编译器必须生成一个move-constructor调用Widget(Widget&&)来创建value对象。在通过右值引用传递的情况下，不需要进行任何调用，因为右值引用直接传递给方法。通常这无关紧要，因为move构造函数是微不足道的（或默认设置），并且在大多数情况下都内联。（您可以在gcc.godbolt.org上进行检查-在您的示例中声明move构造函数Widget(Widget&&);，它将显示在程序集中）

所以我的经验法则是这样的：

• 如果对象表示唯一资源（没有复制语义），则我更喜欢使用pass-by-rvalue-reference，
• 否则，如果从逻辑上讲移动或复制对象都有意义，则使用值传递。