我的第一个答案是对移动语义的极为简化的介绍，故意保留了许多细节以使其保持简单。但是，还有更多的语义要移动，我认为现在是第二次填补空白的时候了。第一个答案已经很老了，用简单的完全不同的文本替换它是不合适的。我认为它仍然可以很好地作为第一个介绍。但是，如果您想深入了解，请继续阅读:)
Stephan T. Lavavej花时间提供了宝贵的反馈意见。非常感谢，斯蒂芬！
介绍
移动语义允许对象在一定条件下获得其他对象外部资源的所有权。这在两个方面很重要：
把昂贵的副本变成便宜的举动。有关示例，请参见我的第一个答案。请注意，如果一个对象不管理至少一个外部资源（直接或通过其成员对象间接管理），则移动语义将不会比复制语义提供任何优势。在这种情况下，复制对象并移动对象意味着完全相同的事情：
class cannot_benefit_from_move_semantics
{
int a; // moving an int means copying an int
float b; // moving a float means copying a float
double c; // moving a double means copying a double
char d[64]; // moving a char array means copying a char array
// ...
};
实施安全的“仅移动”类型；也就是说，复制没有意义，而移动却有意义。示例包括具有唯一所有权语义的锁，文件句柄和智能指针。注意：此答案讨论了std::auto_ptr，已弃用的C ++ 98标准库模板，std::unique_ptr在C ++ 11中已将其替换。中级C ++程序员可能至少有点熟悉std::auto_ptr，并且由于它显示的“移动语义”，这似乎是讨论C ++ 11中移动语义的一个很好的起点。YMMV。
这是什么举动？
C ++ 98标准库提供了一个智能指针，该指针具有称为的唯一所有权语义std::auto_ptr<T>。如果您不熟悉auto_ptr，它的目的是即使在遇到异常的情况下，也始终保证释放动态分配的对象：
{
std::auto_ptr<Shape> a(new Triangle);
// ...
// arbitrary code, could throw exceptions
// ...
} // <--- when a goes out of scope, the triangle is deleted automatically
不寻常的auto_ptr是它的“复制”行为：
auto_ptr<Shape> a(new Triangle);
+---------------+
| triangle data |
+---------------+
^
|
|
|
+-----|---+
| +-|-+ |
a | p | | | |
| +---+ |
+---------+
auto_ptr<Shape> b(a);
+---------------+
| triangle data |
+---------------+
^
|
+----------------------+
|
+---------+ +-----|---+
| +---+ | | +-|-+ |
a | p | | | b | p | | | |
| +---+ | | +---+ |
+---------+ +---------+
注意如何初始化b与a不不复制三角形，而是转移三角形的从所有权a到b。我们也说“ a被移入 b ”或者“三角形移动从a 到 b ”。这听起来可能会造成混淆，因为三角形本身始终位于内存中的同一位置。
移动对象意味着将其管理的某些资源的所有权转让给另一个对象。
的复制构造函数auto_ptr可能看起来像这样（有所简化）：
auto_ptr(auto_ptr& source) // note the missing const
{
p = source.p;
source.p = 0; // now the source no longer owns the object
}
危险无害的举动
危险的auto_ptr是，在语法上看起来像副本的实际上是移动。尝试在from上调用成员函数auto_ptr将调用未定义的行为，因此您必须非常小心，不要auto_ptr在将其从from位置移开后使用：
auto_ptr<Shape> a(new Triangle); // create triangle
auto_ptr<Shape> b(a); // move a into b
double area = a->area(); // undefined behavior
但是auto_ptr并不总是危险的。工厂功能非常适合auto_ptr以下情况：
auto_ptr<Shape> make_triangle()
{
return auto_ptr<Shape>(new Triangle);
}
auto_ptr<Shape> c(make_triangle()); // move temporary into c
double area = make_triangle()->area(); // perfectly safe
请注意，两个示例如何遵循相同的语法模式：
auto_ptr<Shape> variable(expression);
double area = expression->area();
但是，其中一个调用了未定义的行为，而另一个则没有。那么，表达式a和之间有什么区别make_triangle()？他们不是同一个类型吗？确实是，但是它们具有不同的价值类别。
值类别
显然，a表示auto_ptr变量的表达式make_triangle()与表示返回auto_ptr按值的函数的调用的表达式之间必须有一些深远的区别，因此auto_ptr每次调用时都会创建一个新的临时对象。a是左值的示例，而是右值make_triangle()的示例。
从这样的左值移动a很危险，因为稍后我们可以尝试通过调用成员函数a，从而调用未定义的行为。另一方面，从rvalue这样的make_triangle()值移出是完全安全的，因为在复制构造函数完成其工作之后，我们无法再次使用临时变量。没有表示所说的临时的表达。如果我们只是简单地make_triangle()再次写，就会得到一个不同的临时值。实际上，移出的临时目录已经在下一行中消失了：
auto_ptr<Shape> c(make_triangle());
^ the moved-from temporary dies right here
请注意，字母l和r在作业的左侧和右侧都有历史渊源。在C ++中，这不再是正确的，因为有些左值不能出现在赋值的左侧（例如没有赋值运算符的数组或用户定义的类型），并且有些左值可以（类类型的所有右值）和赋值运算符）。
类类型的右值是一个表达式，其求值创建一个临时对象。在正常情况下，相同作用域内的其他任何表达式都不会表示相同的临时对象。
右值参考
我们现在知道，从左值移出有潜在的危险，但是从右值移出是无害的。如果C ++具有支持将左值参数与右值参数区分开的语言，则我们可以完全禁止从左值移动或至少使从左值移动明确在调用站点上，这样我们就不会再偶然移动了。
C ++ 11对这个问题的答案是右值引用。右值引用是仅绑定到右值的一种新型引用，语法为X&&。好的旧引用X&现在称为左值引用。（请注意，X&&是不是向基准的基准;没有这样的东西在C ++中）。
如果我们综合const考虑，我们已经有四种不同类型的参考。X它们可以绑定哪种类型的表达式？
lvalue const lvalue rvalue const rvalue
---------------------------------------------------------
X& yes
const X& yes yes yes yes
X&& yes
const X&& yes yes
在实践中，您可以忘记const X&&。被限制为从右值读取不是很有用。
右值引用X&&是一种仅绑定到右值的新型引用。
隐式转换
右值引用经历了多个版本。从2.1版开始，如果存在从到的隐式转换，则右值引用X&&也将绑定到不同类型的所有值类别。在这种情况下，将创建一个临时类型，并将右值引用绑定到该临时上：YYXX
void some_function(std::string&& r);
some_function("hello world");
在上面的示例中，"hello world"是类型的左值const char[12]。由于存在的隐式转换从const char[12]通过const char*到std::string，临时类型的std::string被创建，并且r被绑定到该暂时的。这是右值（表达式）和临时对象（对象）之间的区别有点模糊的情况之一。
移动构造函数
一个带有X&&参数的函数的有用示例是move构造函数 X::X(X&& source)。其目的是将托管资源的所有权从源转移到当前对象。
在C ++ 11中，std::auto_ptr<T>已被std::unique_ptr<T>rvalue引用所取代。我将开发和讨论的简化版本unique_ptr。首先，我们封装了原始指针并重载了运算符->和*，因此我们的类感觉就像一个指针：
template<typename T>
class unique_ptr
{
T* ptr;
public:
T* operator->() const
{
return ptr;
}
T& operator*() const
{
return *ptr;
}
构造函数获得对象的所有权，而析构函数将其删除：
explicit unique_ptr(T* p = nullptr)
{
ptr = p;
}
~unique_ptr()
{
delete ptr;
}
现在来看看有趣的部分，移动构造函数：
unique_ptr(unique_ptr&& source) // note the rvalue reference
{
ptr = source.ptr;
source.ptr = nullptr;
}
这个move构造函数的功能与auto_ptr复制构造函数的功能完全相同，但是只能提供rvalues：
unique_ptr<Shape> a(new Triangle);
unique_ptr<Shape> b(a); // error
unique_ptr<Shape> c(make_triangle()); // okay
第二行由于a是左值而无法编译，但是该参数unique_ptr&& source只能绑定到右值。这正是我们想要的。危险的举动绝对不能隐含。第三行编译就好了，因为它make_triangle()是一个右值。move构造函数会将所有权从临时所有权转移到c。同样，这正是我们想要的。
移动构造函数将托管资源的所有权转移到当前对象中。
移动分配运算符
最后缺少的部分是移动分配运算符。它的工作是释放旧资源并从其论据中获取新资源：
unique_ptr& operator=(unique_ptr&& source) // note the rvalue reference
{
if (this != &source) // beware of self-assignment
{
delete ptr; // release the old resource
ptr = source.ptr; // acquire the new resource
source.ptr = nullptr;
}
return *this;
}
};
请注意，移动分配运算符的此实现如何复制析构函数和move构造函数的逻辑。您熟悉复制和交换习惯吗？它也可以作为移动和交换的惯用法应用于移动语义：
unique_ptr& operator=(unique_ptr source) // note the missing reference
{
std::swap(ptr, source.ptr);
return *this;
}
};
现在，它source是type变量unique_ptr，它将由move构造函数初始化；也就是说，参数将被移到参数中。仍然需要将参数设为右值，因为move构造函数本身具有右值引用参数。当控制流到达的结尾时operator=，source超出范围，自动释放旧资源。
移动分配运算符将托管资源的所有权转移到当前对象中，从而释放旧资源。移动和交换习惯简化了实现。
从左值移动
有时，我们想从左值转移。也就是说，有时我们希望编译器将一个左值当作一个右值对待，因此它可以调用move构造函数，即使它可能是不安全的。为此，C ++ 11提供了std::move在header内部调用的标准库函数模板<utility>。这个名字有点不幸，因为std::move只是将一个左值转换为一个右值。它本身不会移动任何东西。它仅允许移动。也许它应该被命名为std::cast_to_rvalue或std::enable_move，但是到目前为止，我们仍然停留在该名称上。
这是您从左值显式移动的方式：
unique_ptr<Shape> a(new Triangle);
unique_ptr<Shape> b(a); // still an error
unique_ptr<Shape> c(std::move(a)); // okay
请注意，在第三行之后，a不再拥有三角形。没关系，因为通过显式编写std::move(a)，我们明确了我们的意图：“亲爱的构造函数，请执行您想进行的任何操作a以进行初始化c；我不再关心a。请随时使用a。”
std::move(some_lvalue) 将左值转换为右值，从而启用后续移动。
X值
请注意，即使std::move(a)是右值，其评估也不会创建临时对象。这个难题迫使委员会引入了第三个价值类别。即使不是传统意义上的右值，也可以绑定到右值引用的东西称为xvalue（eXpiring值）。传统的右值被重命名为prvalue（纯右值）。
prvalue和xvalue均为rvalue。X值和左值都是glvalues（广义左值）。使用图更容易理解这些关系：
expressions
/ \
/ \
/ \
glvalues rvalues
/ \ / \
/ \ / \
/ \ / \
lvalues xvalues prvalues
请注意，只有xvalue才是真正的新值。其余只是由于重命名和分组。
C ++ 98右值在C ++ 11中称为prvalue。用“ prvalue”替换前面段落中所有出现的“ rvalue”。
移出功能
到目前为止，我们已经看到了向局部变量和函数参数的移动。但是也可以朝相反的方向移动。如果函数按值返回，则在调用站点处的某些对象（可能是局部变量或临时对象，但可以是任何类型的对象）都使用该语句后的return表达式作为move构造函数的参数进行初始化：
unique_ptr<Shape> make_triangle()
{
return unique_ptr<Shape>(new Triangle);
} \-----------------------------/
|
| temporary is moved into c
|
v
unique_ptr<Shape> c(make_triangle());
也许令人惊讶的是，自动对象（未声明为的局部变量static）也可以隐式移出函数：
unique_ptr<Shape> make_square()
{
unique_ptr<Shape> result(new Square);
return result; // note the missing std::move
}
move构造函数如何接受左值result作为参数？的范围result即将结束，它将在堆栈展开期间销毁。此后，没人会抱怨这种情况result有所改变。当控制流返回到调用者时，result它不再存在！因此，C ++ 11有一条特殊的规则，该规则允许从函数中返回自动对象而无需编写std::move。实际上，您永远不要使用std::move将自动对象移出函数，因为这会阻止“命名返回值优化”（NRVO）。
切勿使用std::move将自动对象移出功能。
请注意，在两个工厂函数中，返回类型都是一个值，而不是右值引用。右值引用仍然是引用，并且一如既往，您绝对不应返回对自动对象的引用。如果您诱使编译器接受您的代码，则调用者最终会得到悬挂的引用，如下所示：
unique_ptr<Shape>&& flawed_attempt() // DO NOT DO THIS!
{
unique_ptr<Shape> very_bad_idea(new Square);
return std::move(very_bad_idea); // WRONG!
}
切勿通过右值引用返回自动对象。移动是由移动构造函数专门执行的std::move，而不是由而不是仅将右值绑定到右值引用来执行。
成为会员
迟早，您将要编写如下代码：
class Foo
{
unique_ptr<Shape> member;
public:
Foo(unique_ptr<Shape>&& parameter)
: member(parameter) // error
{}
};
基本上，编译器会抱怨这parameter是一个左值。如果查看其类型，则会看到一个右值引用，但右值引用仅表示“绑定到右值的引用”；它并不能意味着引用本身就是右值！确实，parameter只是一个具有名称的普通变量。您可以parameter在构造函数的主体内随意使用它，它始终表示同一对象。隐式离开它是危险的，因此该语言禁止这样做。
就像任何其他变量一样，命名的右值引用是左值。
解决方案是手动启用移动：
class Foo
{
unique_ptr<Shape> member;
public:
Foo(unique_ptr<Shape>&& parameter)
: member(std::move(parameter)) // note the std::move
{}
};
您可能会争辩说，parameter在初始化后不再使用它member。为什么没有std::move像返回值一样静默插入的特殊规则？可能是因为这会给编译器实现者带来太多负担。例如，如果构造函数主体在另一个翻译单元中怎么办？相比之下，返回值规则仅需检查符号表即可确定return关键字后的标识符是否表示自动对象。
您也可以parameter按值传递。对于像这样的仅移动类型unique_ptr，似乎还没有确定的习语。就个人而言，我更喜欢按值传递，因为它可以减少界面中的混乱情况。
特殊成员功能
C ++ 98根据需要隐式声明三个特殊的成员函数，即在某个地方需要它们时：拷贝构造函数，拷贝赋值运算符和析构函数。
X::X(const X&); // copy constructor
X& X::operator=(const X&); // copy assignment operator
X::~X(); // destructor
右值引用经历了多个版本。从3.0版开始，C ++ 11根据需要声明了两个附加的特殊成员函数：move构造函数和move赋值运算符。请注意，VC10和VC11都不符合版本3.0，因此您必须自己实现它们。
X::X(X&&); // move constructor
X& X::operator=(X&&); // move assignment operator
仅当没有手动声明任何特殊成员函数时，才隐式声明这两个新的特殊成员函数。同样，如果您声明自己的move构造函数或move赋值运算符，则不会隐式声明副本构造函数或副本赋值运算符。
这些规则在实践中意味着什么？
如果您编写的类没有非托管资源，则无需自己声明这五个特殊成员函数中的任何一个，您将获得正确的复制语义并免费移动语义。否则，您将必须自己实现特殊的成员函数。当然，如果您的类没有从移动语义中受益，则无需实现特殊的移动操作。
请注意，可以将复制赋值运算符和移动赋值运算符融合为单个统一赋值运算符，并按值取其参数：
X& X::operator=(X source) // unified assignment operator
{
swap(source); // see my first answer for an explanation
return *this;
}
这样，要实现的特殊成员函数的数量从五个减少到四个。在这里，在异常安全性和效率之间进行权衡，但是我不是这个问题的专家。
转发参考（以前称为通用参考）
考虑以下功能模板：
template<typename T>
void foo(T&&);
您可能希望T&&只绑定到右值，因为乍一看，它看起来像是右值引用。事实证明，它T&&也绑定到左值：
foo(make_triangle()); // T is unique_ptr<Shape>, T&& is unique_ptr<Shape>&&
unique_ptr<Shape> a(new Triangle);
foo(a); // T is unique_ptr<Shape>&, T&& is unique_ptr<Shape>&
如果参数是类型的右值X，T则推导为X，因此T&&意味着X&&。这就是任何人所期望的。但是，如果参数类型的左值X，因为一个特殊的规则，T被推断为X&，因此T&&将意味着像X& &&。但是由于C ++仍然没有引用的引用概念，因此该类型X& &&被折叠为X&。乍一看这可能让人感到困惑和无用，但是参考折叠对于完美转发是必不可少的（这里不再讨论）。
T &&不是右值引用，而是转发引用。它还绑定到左值，在这种情况下T，T&&它们都是左值引用。
如果要将函数模板限制为右值，可以将SFINAE与特征类型结合使用：
#include <type_traits>
template<typename T>
typename std::enable_if<std::is_rvalue_reference<T&&>::value, void>::type
foo(T&&);
实施搬家
现在您已经了解了参考折叠，以下std::move是实现方法：
template<typename T>
typename std::remove_reference<T>::type&&
move(T&& t)
{
return static_cast<typename std::remove_reference<T>::type&&>(t);
}
如您所见，move多亏转发参考接受任何类型的参数T&&，并且它返回右值参考。在std::remove_reference<T>::type元函数调用是必要的，否则，类型的左值X，返回类型是X& &&，这将折叠成X&。由于t始终是一个左值（请记住，命名的右值引用是左值），但是我们想绑定t到右值引用，因此必须显式t转换为正确的返回类型。返回右值引用的函数的调用本身就是一个xvalue。现在您知道了xvalue的来源;）
返回右值引用（例如）的函数的调用std::move是xvalue。
请注意，在此示例中，通过右值引用返回是很好的，因为t它不表示自动对象，而是表示调用者传递的对象。