如果你真的对移动语义的一个好的、深入的解释感兴趣，我强烈建议你阅读关于它们的原始论文《向C++语言添加移动语义支持的建议》

这本书非常容易阅读和阅读，为他们提供的好处提供了极好的理由。WG21网站上还有其他关于移动语义的最新论文，但这篇文章可能是最直接的，因为它从顶层的角度处理问题，并没有深入到语言的细节。

你知道复制语义是什么意思吗？这意味着您有可复制的类型，对于用户定义的类型，您可以明确地编写复制构造函数和赋值运算符，或者编译器隐式地生成它们。这将复制一份。

移动语义基本上是一种用户定义的类型，带有构造函数，它接受一个非常量的r值引用（使用&&（是两个&符号）的新类型引用），这称为移动构造函数，赋值运算符也是如此。那么，移动构造函数做什么呢？它不是从源参数复制内存，而是将内存从源“移动”到目标。

你什么时候想这样做？那么std:：vector就是一个例子，假设您创建了一个临时std:：vector，然后从一个函数返回它，比如：

std::vector<foo> get_foos();

当函数返回时，复制构造函数将产生开销，如果（在C++0x中也是如此）std:：vector有一个移动构造函数，而不是复制它。它只需要设置指针并将动态分配的内存“移动”到新实例。这有点像std:：auto_ptr的所有权转移语义。

我发现用示例代码来理解移动语义是最容易的。让我们从一个非常简单的字符串类开始，它只包含一个指向堆分配的内存块的指针：

#include <cstring>
#include <algorithm>

class string
{
    char* data;

public:

    string(const char* p)
    {
        size_t size = std::strlen(p) + 1;
        data = new char[size];
        std::memcpy(data, p, size);
    }

既然我们选择自己管理记忆，我们就需要遵循三个法则。我将推迟编写赋值运算符，现在只实现析构函数和复制构造函数：

    ~string()
    {
        delete[] data;
    }

    string(const string& that)
    {
        size_t size = std::strlen(that.data) + 1;
        data = new char[size];
        std::memcpy(data, that.data, size);
    }

复制构造函数定义了复制字符串对象的含义。参数const string&绑定到string类型的所有表达式，允许您在以下示例中创建副本：

string a(x);                                    // Line 1
string b(x + y);                                // Line 2
string c(some_function_returning_a_string());   // Line 3

现在是对移动语义的关键洞察。注意，只有在我们复制x的第一行中，这个深度复制才是真正必要的，因为我们可能希望稍后检查x，如果x发生了某种变化，我们会非常惊讶。你注意到我刚才说了三次x（如果你包括这句话的话是四次），每次都是指同一个对象吗？我们称x等表达式为“lvalues”。

第2行和第3行中的参数不是lvalues，而是rvalues，因为基础字符串对象没有名称，因此客户端无法在稍后的时间点再次检查它们。右值表示在下一个分号处销毁的临时对象（更准确地说：在词汇上包含右值的完整表达式的末尾）。这一点很重要，因为在b和c的初始化过程中，我们可以对源字符串做任何我们想做的事情，而客户端无法分辨出区别！

C++0x引入了一种称为“右值引用”的新机制，允许我们通过函数重载检测右值参数。我们所要做的就是编写一个带有右值引用参数的构造函数。在该构造函数中，我们可以对源代码做任何我们想做的事情，只要我们让它处于某种有效状态：

    string(string&& that)   // string&& is an rvalue reference to a string
    {
        data = that.data;
        that.data = nullptr;
    }

我们在这里做了什么？我们没有深度复制堆数据，而是复制了指针，然后将原始指针设置为null（以防止源对象的析构函数中的“delete[]”释放我们的“刚刚窃取的数据”）。实际上，我们已经“窃取”了最初属于源字符串的数据。同样，关键的见解是，在任何情况下，客户端都无法检测到源代码已被修改。因为我们没有在这里真正复制，所以我们称这个构造函数为“移动构造函数”。它的工作是将资源从一个对象移动到另一个对象，而不是复制它们。

恭喜您，您现在了解了移动语义的基础知识！让我们继续实现赋值运算符。如果您不熟悉复制和交换习惯用法，请学习它并回来，因为它是一个与异常安全相关的很棒的C++习惯用法。

    string& operator=(string that)
    {
        std::swap(data, that.data);
        return *this;
    }
};

嗯，就这样？“右值参考值在哪里？”你可能会问。“我们这里不需要它！”我的回答是：）

请注意，我们通过值传递参数，因此它必须像其他字符串对象一样进行初始化。具体如何初始化？在C++98的早期，答案应该是“复制构造函数”。在C++0x中，编译器根据赋值运算符的参数是左值还是右值，在复制构造函数和移动构造函数之间进行选择。

因此，如果你说a=b，复制构造函数将初始化它（因为表达式b是一个左值），赋值运算符将用新创建的深度副本交换内容。这就是复制和交换习惯用法的定义——制作一个副本，用副本交换内容，然后通过离开范围来删除副本。这里没有什么新鲜事。

但是如果你说a=x+y，move构造函数将初始化它（因为表达式x+y是一个右值），所以不涉及深度复制，只涉及有效的移动。这仍然是一个独立于论点的对象，但它的构造微不足道，因为堆数据不必复制，只需移动即可。不需要复制它，因为x+y是一个右值，同样，可以从右值表示的字符串对象中移动。

总之，复制构造函数进行深度复制，因为源必须保持不变。另一方面，move构造函数可以复制指针，然后将源中的指针设置为null。以这种方式“取消”源对象是可以的，因为客户端无法再次检查对象。

我希望这个例子能传达出要点。为了保持简单，我特意省略了很多关于重新赋值引用和移动语义的内容。如果你想了解更多详情，请参阅我的补充答案。

如果你真的对移动语义的一个好的、深入的解释感兴趣，我强烈建议你阅读关于它们的原始论文《向C++语言添加移动语义支持的建议》

这本书非常容易阅读和阅读，为他们提供的好处提供了极好的理由。WG21网站上还有其他关于移动语义的最新论文，但这篇文章可能是最直接的，因为它从顶层的角度处理问题，并没有深入到语言的细节。

为了说明移动语义的需要，让我们考虑这个没有移动语义的示例：

下面是一个函数，它接受T类型的对象并返回相同类型的对象：

T f(T o) { return o; }
  //^^^ new object constructed

上述函数使用值调用，这意味着当调用此函数时，必须构造一个对象以供函数使用。由于函数也按值返回，因此为返回值构造另一个新对象：

T b = f(a);
  //^ new object constructed

已经构造了两个新对象，其中一个是仅在函数期间使用的临时对象。

当从返回值创建新对象时，调用复制构造函数将临时对象的内容复制到新对象b。函数完成后，函数中使用的临时对象超出范围并被销毁。

现在，让我们考虑一下复制构造函数的作用。

它必须首先初始化对象，然后将所有相关数据从旧对象复制到新对象。根据类的不同，它可能是一个包含大量数据的容器，那么这可能会占用大量的时间和内存

// Copy constructor
T::T(T &old) {
    copy_data(m_a, old.m_a);
    copy_data(m_b, old.m_b);
    copy_data(m_c, old.m_c);
}

使用移动语义，现在可以通过简单地移动数据而不是复制来减少大部分工作的不愉快。

// Move constructor
T::T(T &&old) noexcept {
    m_a = std::move(old.m_a);
    m_b = std::move(old.m_b);
    m_c = std::move(old.m_c);
}

移动数据涉及将数据与新对象重新关联。而且根本不会复制。

这是通过右值引用完成的。右值引用的工作方式与左值引用非常相似，但有一个重要区别：右值引用可以移动，左值不能移动。

来自cpreference.com：

为了使强异常保证成为可能，用户定义的移动构造函数不应抛出异常。事实上，当需要重新定位容器元素时，标准容器通常依赖std:：move_if_noexcept在移动和复制之间进行选择。如果同时提供了复制构造函数和移动构造函数，则重载解析会在参数为右值（prvalue，如无名临时值或xvalue，如std:：move的结果）时选择移动构造函数，而在参数为左值（命名对象或返回左值引用的函数/运算符）时选择复制构造函数。如果只提供了复制构造函数，则所有参数类别都会选择它（只要它引用const，因为rvalues可以绑定到const引用），这使得当移动不可用时，复制成为移动的备用方法。在许多情况下，即使移动构造函数会产生可观察到的副作用，也会对其进行优化，请参见复制省略。当构造函数将右值引用作为参数时，它被称为“移动构造函数”。它没有义务移动任何东西，类不需要有要移动的资源，并且“移动构造函数”可能无法移动资源，因为在允许（但可能不合理）的情况下，参数是常量值引用（constT&&）。

这是Bjarne Stroustrup的《C++编程语言》一书中的答案。如果你不想看视频，可以看下面的文字：

考虑一下这个片段。从运算符+返回涉及将结果从局部变量res复制到调用者可以访问的地方。

Vector operator+(const Vector& a, const Vector& b)
{
    if (a.size()!=b.size())
        throw Vector_siz e_mismatch{};
    Vector res(a.size());
        for (int i=0; i!=a.size(); ++i)
            res[i]=a[i]+b[i];
    return res;
}

我们真的不想要副本；我们只是想从函数中得到结果。所以我们需要移动Vector而不是复制它。我们可以如下定义移动构造函数：

class Vector {
    // ...
    Vector(const Vector& a); // copy constructor
    Vector& operator=(const Vector& a); // copy assignment
    Vector(Vector&& a); // move constructor
    Vector& operator=(Vector&& a); // move assignment
};

Vector::Vector(Vector&& a)
    :elem{a.elem}, // "grab the elements" from a
    sz{a.sz}
{
    a.elem = nullptr; // now a has no elements
    a.sz = 0;
}

&&表示“右值引用”，是我们可以绑定右值的引用。“rvalue”'旨在补充“lvalue”，它大致意思是“可以出现在赋值左侧的值”。因此，rvalue大致意思是：“不能赋值的值”，例如函数调用返回的整数，以及Vectors运算符+（）中的res局部变量。

现在，语句返回res；不会复制！