什么时候应该在函数返回值上使用 std::move？ [复制]

Question

在这种情况下

struct Foo {};
Foo meh() {
  return std::move(Foo());
}

我很确定移动是不必要的，因为新创建的 Foo 将是一个 xvalue。

但是在这种情况下呢？

struct Foo {};
Foo meh() {
  Foo foo;
  //do something, but knowing that foo can safely be disposed of
  //but does the compiler necessarily know it?
  //we may have references/pointers to foo. how could the compiler know?
  return std::move(foo); //so here the move is needed, right?
}

我想需要采取行动吗？

Answer 1

对于return std::move(foo);，move 是多余的，因为 12.8/32：

当满足或将满足省略复制操作的条件时 遇到源对象是函数参数这一事实， 并且要复制的对象由左值指定，重载 为副本选择构造函数的决议首先执行为 如果对象是由右值指定的。

return foo; 是 NRVO 的一种情况，因此允许复制省略。 foo 是一个左值。因此，从foo“复制”到meh的返回值所选择的构造函数必须是移动构造函数（如果存在）。

添加 move 确实有一个潜在的影响：它可以防止移动被忽略，因为 return std::move(foo); 不符合 NRVO 的条件。

据我所知，12.8/32 列出了 only 条件，在这些条件下，左值的副本可以被移动替换。通常不允许编译器在复制后检测到未使用的左值（例如使用 DFA），并主动进行更改。我在这里假设两者之间存在可观察到的差异——如果可观察到的行为相同，则适用“as-if”规则。

因此，要回答标题中的问题，当您希望它被移动并且它不会被移动时，请在返回值上使用std::move。那就是：

• 您希望它被移动，并且
• 它是一个左值，并且
• 它不符合复制省略的条件，并且
• 它不是按值函数参数的名称。

考虑到这非常繁琐，而且移动通常很便宜，你可能想说在非模板代码中你可以稍微简化一下。在以下情况下使用std::move：

• 您希望它被移动，并且
• 它是一个左值，并且
• 您不必担心它。

通过遵循简化的规则，您会牺牲一些移动省略。对于像std::vector 这样移动起来很便宜的类型，你可能永远不会注意到（如果你注意到了，你可以优化）。对于像 std::array 这样的移动成本很高的类型，或者对于您不知道移动是否便宜的模板，您更有可能担心它。

Answer 2

在这两种情况下都不需要移动。在第二种情况下，std::move 是多余的，因为您按值返回一个局部变量，编译器会理解，由于您不再使用该局部变量，因此可以将其移出而不是复制。

Answer 3

在返回值上，如果返回表达式直接引用本地左值的名称（即此时为 xvalue），则不需要 std::move。另一方面，如果返回表达式不是标识符，它不会被自动移动，例如，在这种情况下你需要显式的std::move：

T foo(bool which) {
   T a = ..., b = ...;
   return std::move(which? a : b);
   // alternatively: return which? std::move(a), std::move(b);
}

当直接返回一个命名的局部变量或一个临时表达式时，你应该避免显式的std::move。编译器必须（将来会）在这些情况下自动移动，添加 std::move 可能会影响其他优化。

Answer 4

关于什么时候不应该移动有很多答案，但问题是“什么时候应该移动它？”

这是一个人为的例子，说明何时应该使用它：

std::vector<int> append(std::vector<int>&& v, int x) {
  v.push_back(x);
  return std::move(v);
}

即，当你有一个函数接受一个右值引用，修改它，然后返回它的副本。 （c++20 的行为在这里发生了变化）现在，在实践中，这种设计几乎总是更好：

std::vector<int> append(std::vector<int> v, int x) {
  v.push_back(x);
  return v;
}

这也允许你使用非右值参数。

基本上，如果您想通过移动返回函数中的右值引用，则必须调用std::move。如果你有一个局部变量（不管它是否是参数），隐式返回它moves（这个隐式移动可以被忽略，而显式移动不能）。如果你有一个函数或操作接受局部变量，并返回对所述局部变量的引用，你必须 std::move 才能发生移动（例如，三元 ?: 运算符）。

Answer 5

C++ 编译器可以免费使用std::move(foo):

• 如果已知foo 已到其生命周期的尽头，并且
• 隐式使用 std::move 不会对 C++ 代码的语义产生任何影响，除了 C++ 规范允许的语义影响。

在遵守 C++ 规范规则的同时，它是否能够计算从f(foo); foo.~Foo(); 到f(std::move(foo)); foo.~Foo(); 的哪些转换在性能或内存消耗方面是有利可图的，这取决于 C++ 编译器的优化能力。

---

从概念上来说，2017 年的 C++ 编译器（例如 GCC 6.3.0）能够优化此代码：

Foo meh() {
    Foo foo(args);
    foo.method(xyz);
    bar();
    return foo;
}

进入这段代码：

void meh(Foo *retval) {
   new (retval) Foo(arg);
   retval->method(xyz);
   bar();
}

避免调用Foo的复制构造函数和析构函数。

---

2017 年的 C++ 编译器，例如 GCC 6.3.0，无法优化这些代码：

Foo meh_value() {
    Foo foo(args);
    Foo retval(foo);
    return retval;
}

Foo meh_pointer() {
    Foo *foo = get_foo();
    Foo retval(*foo);
    delete foo;
    return retval;
}

进入这些代码：

Foo meh_value() {
    Foo foo(args);
    Foo retval(std::move(foo));
    return retval;
}

Foo meh_pointer() {
    Foo *foo = get_foo();
    Foo retval(std::move(*foo));
    delete foo;
    return retval;
}

这意味着 2017 年的程序员需要明确指定此类优化。

Answer 6

std::move 从函数返回时完全没有必要，它真正进入了你的领域——程序员——试图照看你应该留给编译器的东西。

当您 std::move 某个函数的某些东西不是该函数的局部变量时会发生什么？你可以说你永远不会写那样的代码，但是如果你写的代码很好，然后重构它并且心不在焉地不改变std::move，会发生什么。您会很高兴跟踪该错误。

另一方面，编译器几乎不会犯这类错误。

另外：需要注意的是，从函数返回局部变量不一定必须创建右值或使用移动语义。

See here.