它们都不会复制，但第二个会指向一个已销毁的向量。命名右值引用在常规代码中几乎不存在。你写它就像用c++ 03写副本一样。

std::vector<int> return_vector()
{
    std::vector<int> tmp {1,2,3,4,5};
    return tmp;
}

std::vector<int> rval_ref = return_vector();

只是现在，矢量被移动了。在绝大多数情况下，类的用户不会处理它的右值引用。

第一个例子

std::vector<int> return_vector(void)
{
    std::vector<int> tmp {1,2,3,4,5};
    return tmp;
}

std::vector<int> &&rval_ref = return_vector();

第一个示例返回一个由rval_ref捕获的临时对象。该临时对象的生命周期将超出rval_ref定义，您可以使用它，就好像您已经按值捕获了它一样。这与以下内容非常相似:

const std::vector<int>& rval_ref = return_vector();

除了在我的重写中，你显然不能以非const的方式使用rval_ref。

第二个例子

std::vector<int>&& return_vector(void)
{
    std::vector<int> tmp {1,2,3,4,5};
    return std::move(tmp);
}

std::vector<int> &&rval_ref = return_vector();

在第二个示例中，您创建了一个运行时错误。Rval_ref现在在函数中保存了对已销毁TMP的引用。运气好的话，这段代码会立即崩溃。

第三个例子

std::vector<int> return_vector(void)
{
    std::vector<int> tmp {1,2,3,4,5};
    return std::move(tmp);
}

std::vector<int> &&rval_ref = return_vector();

你的第三个例子与第一个例子大致相同。std::move在tmp上是不必要的，实际上可能会导致性能下降，因为它会抑制返回值优化。

编写代码的最佳方式是:

最佳实践

std::vector<int> return_vector(void)
{
    std::vector<int> tmp {1,2,3,4,5};
    return tmp;
}

std::vector<int> rval_ref = return_vector();

例如，就像在c++ 03中一样。TMP在return语句中被隐式地视为右值。它将通过返回值优化(不复制，不移动)返回，或者如果编译器决定它不能执行RVO，那么它将使用vector的move构造函数来返回。只有当不执行RVO，并且返回的类型没有移动构造函数时，才会使用复制构造函数进行返回。

不是答案本身，而是一个指导方针。大多数情况下，声明局部T&&变量没有太大意义(就像使用std::vector<int>&& rval_ref一样)。你仍然需要std::move()它们才能在foo(T&&)类型方法中使用。还有一个已经提到的问题，当你试图从函数返回这样的rval_ref时，你会得到标准的reference-to destroyed-temporary-fiasco。

大多数情况下，我会采用以下模式:

// Declarations
A a(B&&, C&&);
B b();
C c();

auto ret = a(b(), c());

你不持有任何对返回的临时对象的引用，因此你避免了(没有经验的)程序员希望使用移动对象的错误。

auto bRet = b();
auto cRet = c();
auto aRet = a(std::move(b), std::move(c));

// Either these just fail (assert/exception), or you won't get 
// your expected results due to their clean state.
bRet.foo();
cRet.bar();

显然，在某些情况下(尽管相当罕见)，函数会真正返回一个T&&，它是一个对非临时对象的引用，您可以将其移动到您的对象中。

关于RVO:这些机制通常工作，编译器可以很好地避免复制，但在返回路径不明显的情况下(异常，如果条件决定你将返回的命名对象，可能还有其他)，引用是你的救星(即使可能更昂贵)。

正如在第一个答案的注释中已经提到的，返回std::move(…);除了返回局部变量之外，Construct可以产生不同的情况。下面是一个可运行的例子，它记录了当你返回一个带有或不带有std::move()的成员对象时会发生什么:

#include <iostream>
#include <utility>

struct A {
  A() = default;
  A(const A&) { std::cout << "A copied\n"; }
  A(A&&) { std::cout << "A moved\n"; }
};

class B {
  A a;
 public:
  operator A() const & { std::cout << "B C-value: "; return a; }
  operator A() & { std::cout << "B L-value: "; return a; }
  operator A() && { std::cout << "B R-value: "; return a; }
};

class C {
  A a;
 public:
  operator A() const & { std::cout << "C C-value: "; return std::move(a); }
  operator A() & { std::cout << "C L-value: "; return std::move(a); }
  operator A() && { std::cout << "C R-value: "; return std::move(a); }
};

int main() {
  // Non-constant L-values
  B b;
  C c;
  A{b};    // B L-value: A copied
  A{c};    // C L-value: A moved

  // R-values
  A{B{}};  // B R-value: A copied
  A{C{}};  // C R-value: A moved

  // Constant L-values
  const B bc;
  const C cc;
  A{bc};   // B C-value: A copied
  A{cc};   // C C-value: A copied

  return 0;
}

假设，返回std::move(some_member);只有当你真的想要移动特定的类成员时才有意义，例如，在类C表示寿命较短的适配器对象的情况下，它的唯一目的是创建结构a的实例。

注意结构A总是从类B复制出来，即使类B对象是r值。这是因为编译器没有办法告诉类B的结构体A的实例不再被使用。在类C中，编译器确实从std::move()中获得了这个信息，这就是为什么结构A会被移动，除非类C的实例是常量。

它们都不会复制，但第二个会指向一个已销毁的向量。命名右值引用在常规代码中几乎不存在。你写它就像用c++ 03写副本一样。

std::vector<int> return_vector()
{
    std::vector<int> tmp {1,2,3,4,5};
    return tmp;
}

std::vector<int> rval_ref = return_vector();

只是现在，矢量被移动了。在绝大多数情况下，类的用户不会处理它的右值引用。

简单的答案是，您应该像编写常规引用代码一样为右值引用编写代码，并且在99%的时间内，您应该在精神上对它们进行相同的处理。这包括所有关于返回引用的旧规则(即永远不要返回对局部变量的引用)。

除非你正在编写一个模板容器类，需要利用std::forward，并且能够编写一个接受左值或右值引用的泛型函数，否则这或多或少是正确的。

move构造函数和move赋值函数的最大优点之一是，如果你定义了它们，编译器可以在RVO(返回值优化)和NRVO(命名返回值优化)调用失败的情况下使用它们。这对于有效地从方法中返回容器和字符串等昂贵的对象来说是相当大的。

右值引用的有趣之处在于，你也可以将它们用作普通函数的参数。这允许你编写对const引用(const foo& other)和右值引用(foo&& other)都有重载的容器。即使参数太笨拙，不能通过简单的构造函数调用传递，也可以这样做:

std::vector vec;
for(int x=0; x<10; ++x)
{
    // automatically uses rvalue reference constructor if available
    // because MyCheapType is an unamed temporary variable
    vec.push_back(MyCheapType(0.f));
}


std::vector vec;
for(int x=0; x<10; ++x)
{
    MyExpensiveType temp(1.0, 3.0);
    temp.initSomeOtherFields(malloc(5000));

    // old way, passed via const reference, expensive copy
    vec.push_back(temp);

    // new way, passed via rvalue reference, cheap move
    // just don't use temp again,  not difficult in a loop like this though . . .
    vec.push_back(std::move(temp));
}

STL容器已经更新到几乎任何东西(散列键和值，向量插入等)都有移动重载，这是你会看到它们最多的地方。

也可以将它们用于普通函数，如果只提供右值引用参数，则可以强制调用者创建对象并让函数执行移动操作。这更像是一个例子，而不是真正的好用法，但在我的呈现库中，我为所有加载的资源分配了一个字符串，以便更容易看到每个对象在调试器中代表什么。界面是这样的:

TextureHandle CreateTexture(int width, int height, ETextureFormat fmt, string&& friendlyName)
{
    std::unique_ptr<TextureObject> tex = D3DCreateTexture(width, height, fmt);
    tex->friendlyName = std::move(friendlyName);
    return tex;
}

这是一种“漏洞抽象”的形式，但允许我利用我必须在大多数时间内创建字符串的事实，并避免再次复制它。这并不是真正的高性能代码，但它是一个很好的例子，说明了人们在掌握该特性时的各种可能性。这段代码实际上要求变量要么是调用的临时变量，要么调用std::move:

// move from temporary
TextureHandle htex = CreateTexture(128, 128, A8R8G8B8, string("Checkerboard"));

or

// explicit move (not going to use the variable 'str' after the create call)
string str("Checkerboard");
TextureHandle htex = CreateTexture(128, 128, A8R8G8B8, std::move(str));

or

// explicitly make a copy and pass the temporary of the copy down
// since we need to use str again for some reason
string str("Checkerboard");
TextureHandle htex = CreateTexture(128, 128, A8R8G8B8, string(str));

但是这不会编译!

string str("Checkerboard");
TextureHandle htex = CreateTexture(128, 128, A8R8G8B8, str);