C++11之“move”语意

原文来自：http://blog.smartbear.com/c-plus-plus/c11-tutorial-introducing-the-move-constructor-and-the-move-assignment-operator/
by Danny Kalev

拷贝构造函数好像是C++1989年的话题。不过，现在新版本的C++标准极大地影响了C++的类设计。这里可以找到move语意对“对象”的行为影响、以及如何实现move构造函数和move等号重载函数。

新的C++标准在2011年9月份发布，因此，大家都管它叫C++11。它包含了TR1库和一大堆新的核心级新功能。其中几个比较重要的有：

1.  初始化列表 Initializer lists.
2.  统一初始化符号 Uniform initialization notation.
3.  Lambda函数和表达式
4.  强类型的enum
5.  自动化地变量声明 Automatic type deduction in declarations.
6.  __thread_local存储类 __thread_local storage class.
7.  控制和查询对象对齐 Control and query of object alignment.
8.  静态断言 Static assertions.
9.  long long类型
10.  可变长度的模板 Variadic templates.

这些特性都是非常重要的，但是还有一个更为重要的特性是：右值引用。

一、是时候引入右值引用了。

右值引用是一个新的类型的引用变量，它可以用于引用右值。右值简单说，就是单纯的数据，比如算术运算的临时结果。在没有右值引用时，你肯定不能安全地把这样的数据传给引用类型。
在技术上说，一个右值是一个匿名的变量，它只在程序运行过程中求值时，临时使用到。举个例子：
x + (y * z); // 一个 C++ 的算术运算表达式。会生成一个临时值。
在C++里，执行这段代码会创建一个临时变量（一个右值），先用来保存y * z计算出来的值，然后再给它加上x。理论上说，程序走到分号时，就开始计算这个表达式的值了。

右值引用的声明方式是像下面这样的：
std::string&& rrstr; //C++右值引用变量。
原来C++的引用声明是这样的：
std::string& ref;
这样的声明现在为了区别，叫个左值引用。

实际上，代码里的右值引用到处都在发生，甚至在你写代码的不经意间。在C++11里，它引入了新的语法，同时也改变了C++对象的生命周期。要想更好地理解这引新东西。我们引入另一个概念：“move”语意。

二、“移动”语意是啥

在以前，复制是从一个对象把数据传给另一个对象的唯一方法。把字符串对象source赋给target，则结果是source和target两个对象具有相同的字符串。
在现实世界中的很多场景中，代码中要执行的不是复制数据，而是移动数据。当流氓房屋中介从我要房租时，钱是从我这里“移动”到他们的账上去了。当我把SIM卡从一个手机里拿出来后，是要“移动”到另一个手机里装上去的。再比如从图书馆借一本书……
从概念上理清了“复制”和“移动”语意的区别，现在回到C++上来。在C++上是同理的。C++中，移动操作一般会比复制操作要快一些。C++中移动数据只是进行一些赋值操作，而复制则应该创建一个新的内存空间，保证这块空间和被复制的对象内容是一样的。C++中最典型地例子便是函数返回对象值的时候：

    string func()
    {
        string s;
        // do something with s
        return s;
    }
    ///...
    string mystr = func();

在这段代码里，当func()函数返回时，C++会创建一个临时变量来存储返回值s。然后清理函数的栈空间内存。s的析构函数会被调用。那个临时变量会被用来传给mystr变量的拷贝构造函数。从而复制出来一个mystr变量来。在这之后，这个临时变量会被清理掉，调用它的析构函数。如果引用移动语意，就不会在对象间产生那么多的复杂的构造、析构调用了。
相对来说，移动一个string对象几乎是没有资源消耗的。移动只是把源的值传给目标变量。相反，复制则需要创建新的内存空间，然后复制对象里的内容。

三、“移动”：特殊的成员函数

C++11引入了两个新的特殊成员函数：“移动”构造函数和“移动”赋值重载函数。加上原来的几个：

1. 默认构造函数
2. 拷贝函数函数
3. 复制赋值重载函数
4. 析构函数

现在，如果一个类没有用户自定义的成员函数。C++就会自动为其生成5个(或者6个)默认的成员函数。包含移动构造函数和移动赋值重载函数。例如：
class s{};
这个类没有用户自定义的成员函数。这样的话，C++就会自动地为隐式地声明那6个成员函数，在有些情况下，隐式声明的成员函数也会成为隐式定义的成员函数。隐式的“移动”成员函数，执行的是将对象成员依次“移动”过来。移动时会递归地调用成员对象的“移动”构造函数。
被“移动”的对象会怎样？这个对象的状态将是未定义的。但是不管怎样，都应该认为一个被移动之后的对象是不能再拥有任何资源。就像是一个空对象一样。可以想象移动一个字符串s1到s2，执行完“移动”操作后，s2会和之前的s1一样，s1则会成为一个空字符串。

四、写一个“移动”构造函数

一个“移动”构造函数的例子：
C::C(C&& other); //C++11 move constructor.
这个构造函数不应该申请新的资源。它应该收纳other对象里的内容。然后置other为初始的空状态。
我们再举一个具体的例子介绍一下，假如你正在设计一个MemoryPage类，来处理缓存：

    class MemoryPage
    {
        size_t size;
        char* buf;
    public:
        explicit MemoryPage(int sz=512):size(sz), buf(newchar[size]) {}
        ~MemoryPage() {delete[] buf;}
        //typical C++03 copy ctor and assignment operator
        MemoryPage(const MemoryPage&);
        MemoryPage& operator=(const MemoryPage&);
    };

往这个类里面增加一个典型的“移动”构造函数：

    //C++11
    MemoryPage(MemoryPage&& other): size(0), buf(nullptr)
    {
        // pilfer other's resource.
        size = other.size;
        buf = other.buf;
        // reset other.
        other.size = 0;
        other.buf = nullptr;
    }

使用“移动”构造函数，可以提高程序的执行效率。因为它既不执行申请内存，也不执行内存复制的操作。
写一个“移动”赋值重载函数
“移动”等号重载函数如下：
C& C::operator=(C&& other);//C++11 move assignment operator.
“移动"赋值重载函数和拷贝构造函数有一点类似，除了在执行赋值前，要把自己的资源释放掉这一点。“移动”赋值重载函数执行以下4个逻辑：

1. 释放当前*this所拥有的资源。
2. 占用other的资源。
3. 设置other为初始值状态。
4. 返回*this。

一个“移动”赋值重载函数的例子如下：

    //C++11
    MemoryPage& MemoryPage::operator=(MemoryPage&& other)
    {
        if (this != other)
        {
            //release the current object's resources.
            delete[] buf;
            size = 0;
            //pilfer other's
            size = other.size;
            buf = other.buf;
            //reset other
            other.size = 0;
            other.buf = nullptr;
        }
        return *this;
    }

五、重载函数

C++11已经修改了重载处理，以便于让C++11支持右值引用。C++的标准函数库中也要进行修改以提供支持，比如std::vector::push_back()现在就定义了两个重载的函数：一个是传统的传入一个左值的const T&函数；另一个是新增加的传入一个T&&右值的函数。
这个例子就是用一个vector来保存两个MemoryPage对象：

    #include <vector>
    using namespace std;
    int main()
    {
        vector<MemoryPage> vm;
        vm.push_back(MemoryPage(1024));
        vm.push_back(MemoryPage(2048));
    }

这里的两个push_back操作都是传入的右值。因此会调用push_back(T&&)那个函数。push_back就会直接把MemoryPage的内部数据直接占用，省去很多麻烦。在C++11以前的编译器中，这样的代码会调用MemoryPage的拷贝构造函数，创建MemoryPage的拷贝。

下面的代码是调用push_back(const T&)的例子：

    #include <vector>
    using namespace std;
    int main()
    {
        vector<MemoryPage> vm;
        MemoryPage mp1(1024);//lvalue
        vm.push_back(mp1);//push_back(const T&)
    }

如果你在代码里确实就想让它调用push_back(T&&),则可以加一个类型强转：
vm.push_back(static_cast<MemoryPage&&>(mp1));//calls push_back(T&&)
或者，使用C++11新引入的标准函数实现：
vm.push_back(std::move(mp1));//calls push_back(T&&)
看样子，push_back(T&&)非常值得一用，用这个函数，就能避免很多不经意的无用的操作了。不过我们要注意的一点就是，push_back(T&&)函数会把参数对象置空，如果你想在执行完push_back操作后，还能再使用mp1这个变量，则肯定是要使用旧的拷贝构造函数的。很多情况下，一个类的对象在某个地方需要使用拷贝方式，在另一个地方则使用移动方式更合理。

六、总结

C++11变得比原来的C++更好了。它引入的右值引用和移动语意减少了很多不必要的复制操作，在对很多旧的代码几乎不改动的情况下，提高了运行效率。“移动”构造函数和“移动”赋值重载运算符是“移动”操作的核心。“move”语意在C++中酝酿了很久。其带来的好处也是显而易见的。我肯定将来很多其它的语言也会逐渐引入C++11的“move”语意的。