如果我们有 (N)RVO，什么时候真正调用移动构造函数？

Question

我从这里的几个问题中了解到，当按值返回对象时，(N)RVO 会阻止调用移动构造函数。经典例子：

struct Foo {
  Foo()            { std::cout << "Constructed\n"; }
  Foo(const Foo &) { std::cout << "Copy-constructed\n"; }
  Foo(Foo &&)      { std::cout << "Move-constructed\n"; }
  ~Foo()           { std::cout << "Destructed\n"; }
};

Foo makeFoo() {
  return Foo();
}

int main() { 
  Foo foo = makeFoo(); // Move-constructor would be called here without (N)RVO
}

启用 (N)RVO 的输出是：

Constructed
Destructed

那么在什么情况下会调用移动构造函数，而不管 (N)RVO 是否存在？你能提供一些例子吗？换句话说：如果 (N)RVO 默认执行其优化工作，我为什么要关心实现移动构造函数？

Answer 1

首先，您可能应该确保 Foo 跟在 rule of three/five and has move/copy assignment operators. And it is good practice 之后，移动构造函数和移动赋值运算符是 noexcept:

struct Foo {
  Foo()                           { std::cout << "Constructed\n"; }
  Foo(const Foo &)                { std::cout << "Copy-constructed\n"; }
  Foo& operator=(const Foo&)      { std::cout << "Copy-assigned\n"; return *this; }
  Foo(Foo &&)            noexcept { std::cout << "Move-constructed\n"; }
  Foo& operator=(Foo &&) noexcept { std::cout << "Move-assigned\n"; return *this; }

  ~Foo()                    { std::cout << "Destructed\n"; }
};

在大多数情况下，您可以遵循 rule of zero 并且实际上不需要定义任何这些特殊成员函数，编译器会为您创建它们，但它对这个目的很有用。

(N)RVO 仅适用于函数 return 值。例如，它不适用于函数参数。当然，编译器可以在 "as-if" 规则下应用它喜欢的任何优化，因此我们在制作琐碎的示例时必须小心。

函数参数

有很多情况会调用移动构造函数或移动赋值运算符。但一个简单的例子是，如果您使用 std::move 将所有权转移给接受按值或右值引用参数的函数：

void takeFoo(Foo foo) {
  // use foo...
}

int main() { 
  Foo foo = makeFoo();

  // set data on foo...

  takeFoo(std::move(foo));
}

Output:

Constructed
Move-constructed
Destructed
Destructed

用于标准库容器

如果你有一个std::vector<Foo>，移动构造函数的一个非常有用的情况是。当您 push_back 将对象放入容器时，它有时必须重新分配并将所有现有对象移动到新内存。如果 Foo 上有可用的有效移动构造函数，它将使用它而不是复制：

int main() { 
  std::vector<Foo> v;
  std::cout << "-- push_back 1 --\n";
  v.push_back(makeFoo());
  std::cout << "-- push_back 2 --\n";
  v.push_back(makeFoo());
}

Output:

-- push_back 1 --
Constructed
Move-constructed  <-- move new foo into container
Destructed        
-- push_back 2 --
Constructed
Move-constructed  <-- move existing foo to new memory
Move-constructed  <-- move new foo into container
Destructed
Destructed
Destructed
Destructed

构造函数成员初始化列表

我发现移动构造函数在构造函数成员初始化列表中很有用。假设您有一个包含 Foo 的 class FooHolder。然后你可以定义一个构造函数，它接受一个 Foo by-value 并将其移动到成员变量中：

class FooHolder {
  Foo foo_;
public:
  FooHolder(Foo foo) : foo_(std::move(foo)) {} 
};

int main() { 
  FooHolder fooHolder(makeFoo());
}

Output:

Constructed
Move-constructed
Destructed
Destructed

这很好，因为它允许我定义一个接受左值或右值而没有不必要的副本的构造函数。

击败 NVRO 的案例

RVO 始终适用，但也有击败 NVRO 的情况。例如，如果您有两个命名变量，并且 return 变量的选择在编译时未知：

Foo makeFoo(double value) {
  Foo f1;
  Foo f2;
  if (value > 0.5)
    return f1;
  return f2;
}

Foo foo = makeFoo(value);

Output:

Constructed
Constructed
Move-constructed
Destructed
Destructed
Destructed

或者如果 return 变量也是一个函数参数：

Foo appendToFoo(Foo foo) {

  // append to foo...

  return foo;
}

int main() { 
  Foo f1;
  Foo f2 = appendToFoo(f1);
}

Output:

Constructed
Copy-constructed
Move-constructed
Destructed
Destructed
Destructed

为右值优化 setters

移动赋值运算符的一种情况是，如果你想为右值优化 setter。假设您有一个包含 Foo 的 FooHolder 并且您想要一个 setFoo 成员函数。那么如果你想优化左值和右值，你应该有两个重载。一个接受常量引用，另一个接受右值引用：

class FooHolder {
  Foo foo_;
public:
  void setFoo(const Foo& foo) { foo_ = foo; }
  void setFoo(Foo&& foo) { foo_ = std::move(foo); }
};

int main() { 
  FooHolder fooHolder;  
  Foo f;
  fooHolder.setFoo(f);  // lvalue
  fooHolder.setFoo(makeFoo()); // rvalue
}

Output:

Constructed
Constructed
Copy-assigned  <-- setFoo with lvalue
Constructed
Move-assigned  <-- setFoo with rvalue
Destructed
Destructed
Destructed

如果我们有 (N)RVO，什么时候真正调用移动构造函数？

When the move constructor is actually called if we have (N)RVO?

c++

c++11

move-semantics

rvo

nrvo

函数参数

用于标准库容器

构造函数成员初始化列表

击败 NVRO 的案例

为右值优化 setters