Question

我已经从SO的几个问题中了解到，当一个对象按值返回时，（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之后，并且有移动/复制赋值运算符。移动构造函数和移动赋值运算符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仅用于函数返回值。例如，它不适用于功能参数。当然，编译器可以在＆＃34; as-if＆＃34;下使用它喜欢的任何优化。规则所以我们在制作琐碎的例子时要小心。

功能参数

在许多情况下，将调用move-constructor或move-assignment运算符。但一个简单的例子是，如果您使用std::move将所有权转移到接受参数值或rvalue-reference的函数：

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>，那么move-constructor的一个非常有用的例子。当您push_back对象进入容器时，它偶尔会重新分配并将所有现有对象移动到新内存中。如果Foo上有可用的有效move-constructor，它将使用它而不是复制：

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

构造函数成员初始值设定项列表

我发现move-constructors在构造函数成员初始化列表中很有用。假设您有一个包含FooHolder的班级Foo。然后，您可以定义一个构造函数，该构造函数采用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失败。例如，如果您有两个命名变量，并且在编译时不知道返回变量的选择：

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

或者，如果返回变量也是函数参数：

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

优化rvalues的设置者

移动赋值运算符的一种情况是，如果要为rvalues优化setter。假设您有一个包含FooHolder的{{1}}，并且您想要一个Foo成员函数。然后，如果要优化左值和右值，则应该有两个重载。一个接受const的引用，另一个接受rvalue-reference：

setFoo

Output：

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
}

如果我们有（N）RVO，实际调用移动构造函数？

1 个答案:

功能参数

用于标准库容器

构造函数成员初始值设定项列表

击败NVRO的案件

优化rvalues的设置者