移动构造函数和移动赋值

移动语义，简单来说解决的是各种情形下对象的资源所有权转移的问题。而在C++11之前，移动语义的缺失是C++饱受诟病的问题之一。

举个栗子。

问题一：如何将大象放入冰箱？
答案是众所周知的。首先你需要有一台特殊的冰箱，这台冰箱是为了装下大象而制造的。你打开冰箱门，将大象放入冰箱，然后关上冰箱门。

问题二：如何将大象从一台冰箱转移到另一台冰箱？
普通解答：打开冰箱门，取出大象，关上冰箱门，打开另一台冰箱门，放进大象，关上冰箱门。
2B解答：在第二个冰箱中启动量子复制系统，克隆一只完全相同的大象，然后启动高能激光将第一个冰箱内的大象气化消失。
等等，这个2B解答听起来很耳熟，这不就是C++中要移动一个对象时所做的事情吗？

“移动”，这是一个三岁小孩都明白的概念。将大象（资源）从一台冰箱（对象）移动到另一台冰箱，这个行为是如此自然，没有任何人会采用先复制大象，再销毁大象这样匪夷所思的方法。C++通过拷贝构造函数和拷贝赋值操作符为类设计了拷贝/复制的概念，但为了实现对资源的移动操作，调用者必须使用先复制、再析构的方式。否则，就需要自己实现移动资源的接口。

为了实现移动语义，首先需要解决的问题是，如何标识对象的资源是可以被移动的呢？这种机制必须以一种最低开销的方式实现，并且对所有的类都有效。C++的设计者们注意到，大多数情况下，右值所包含的对象都是可以安全的被移动的。

右值（相对应的还有左值）是从C语言设计时就有的概念，但因为其如此基础，也是一个最常被忽略的概念。不严格的来说，左值对应变量的存储位置，而右值对应变量的值本身。C++中右值可以被赋值给左值或者绑定到引用。类的右值是一个临时对象，如果没有被绑定到引用，在表达式结束时就会被废弃。于是我们可以在右值被废弃之前，移走它的资源进行废物利用，从而避免无意义的复制。被移走资源的右值在废弃时已经成为空壳，析构的开销也会降低。

右值中的数据可以被安全移走这一特性使得右值被用来表达移动语义。以同类型的右值构造对象时，需要以引用形式传入参数。右值引用顾名思义专门用来引用右值，左值引用和右值引用可以被分别重载，这样确保左值和右值分别调用到拷贝和移动的两种语义实现。对于左值，如果我们明确放弃对其资源的所有权，则可以通过std::move()来将其转为右值引用。std::move()实际上是static_cast<T&&>()的简单封装。

右值引用至少可以解决以下场景中的移动语义缺失问题：

• 按值传入参数

构造a时，调用了一次字符串的构造函数和一次字符串的移动构造函数。如果使用const string& name接收参数，那么会有一次构造函数和一次拷贝构造，以及一次non-trivial的析构。尽管看起来很蛋疼，尽管编译器还有优化，但从语义来说按值传入参数是最优的方式。

如果你要在构造函数中接收std::shared_ptr<X>并且存入类的成员（这是非常常见的），那么按值传入更是不二选择。拷贝std::shared_ptr<X>需要线程同步，相比之下移动std::shared_ptr是非常轻松愉快的。

• 按值返回

void str_split(const string& s, vector<string>* vec); // 一个按值语义定义的字符串拆分函数。这里不考虑分隔符，假定分隔符是固定的。

1 vector<string> str_split(const string& s) {
2   vector<string> v;
3   // ...
4   return v; // v是左值，但优先移动，不支持移动时仍可复制。
5 }

1 unique_ptr<SomeObj> create_obj(/*...*/) {
2   unique_ptr<SomeObj> ptr(new SomeObj(/*...*/));
3   ptr->foo(); // 一些可能的初始化
4   return ptr;
5 }

当然还有更简单的形式

unique_ptr<SomeObj> create_obj(/*...*/) {
  return unique_ptr<SomeObj>(new SomeObj(/*...*/));
}

二、使用方法

基类：

 1 class MemoryBlock  
 2 {  
 3 public:  
 4   
 5    // Simple constructor that initializes the resource.  
 6    explicit MemoryBlock(size_t length)  
 7       : _length(length)  
 8       , _data(new int[length])  
 9    {  
10       std::cout << "In MemoryBlock(size_t). length = "  
11                 << _length << "." << std::endl;  
12    }  
13   
14    // Destructor.  
15    ~MemoryBlock()  
16    {  
17       std::cout << "In ~MemoryBlock(). length = "  
18                 << _length << ".";  
19   
20       if (_data != nullptr)  
21       {  
22          std::cout << " Deleting resource.";  
23          // Delete the resource.  
24          delete[] _data;  
25       }  
26   
27       std::cout << std::endl;  
28    }  
29   
30    // Copy constructor.  
31    MemoryBlock(const MemoryBlock& other)  
32       : _length(other._length)  
33       , _data(new int[other._length])  
34    {  
35       std::cout << "In MemoryBlock(const MemoryBlock&). length = "   
36                 << other._length << ". Copying resource." << std::endl;  
37   
38       std::copy(other._data, other._data + _length, _data);  
39    }  
40   
41    // Copy assignment operator.  
42    MemoryBlock& operator=(const MemoryBlock& other)  
43    {  
44       std::cout << "In operator=(const MemoryBlock&). length = "   
45                 << other._length << ". Copying resource." << std::endl;  
46   
47       if (this != &other)  
48       {  
49          // Free the existing resource.  
50          delete[] _data;  
51   
52          _length = other._length;  
53          _data = new int[_length];  
54          std::copy(other._data, other._data + _length, _data);  
55       }  
56       return *this;  
57    }  
58   
59    // Retrieves the length of the data resource.  
60    size_t Length() const  
61    {  
62       return _length;  
63    }  
64   
65 private:  
66    size_t _length; // The length of the resource.  
67    int* _data; // The resource.  
68 };  

移动构造函数：

1. 定义一个空的构造函数方法，该方法采用一个对类类型的右值引用作为参数，如以下示例所示：
2. 在移动构造函数中，将源对象中的类数据成员添加到要构造的对象：
3. 将源对象的数据成员分配给默认值。 这可以防止析构函数多次释放资源（如内存）:

    1 // Move constructor.  
    2 MemoryBlock(MemoryBlock&& other)  
    3    : _data(nullptr)  
    4    , _length(0)  
    5 {  
    6    std::cout << "In MemoryBlock(MemoryBlock&&). length = "   
    7              << other._length << ". Moving resource." << std::endl;  
    8   
    9    // Copy the data pointer and its length from the   
   10    // source object.  
   11    _data = other._data;  
   12    _length = other._length;  
   13   
   14    // Release the data pointer from the source object so that  
   15    // the destructor does not free the memory multiple times.  
   16    other._data = nullptr;  
   17    other._length = 0;  
   18 }  

    

移动赋值运算符：

3、在条件语句中，从要将其赋值的对象中释放所有资源（如内存）。以下示例从要将其赋值的对象中释放 _data 成员，执行第一个过程中的步骤 2 和步骤 3 以将数据成员从源对象转移到要构造的对象，

4、返回对当前对象的引用，如以下示例所示：

 1 MemoryBlock& operator=(MemoryBlock&& other)  
 2 {  
 3    std::cout << "In operator=(MemoryBlock&&). length = "   
 4              << other._length << "." << std::endl;  
 5   
 6    if (this != &other)  
 7    {  
 8       // Free the existing resource.  
 9       delete[] _data;  
10   
11       // Copy the data pointer and its length from the   
12       // source object.  
13       _data = other._data;  
14       _length = other._length;  
15   
16       // Release the data pointer from the source object so that  
17       // the destructor does not free the memory multiple times.  
18       other._data = nullptr;  
19       other._length = 0;  
20    }  
21    return *this;  
22 }  

 1 class A
 2 {
 3 public:
 4     int *p = new int;
 5     string str = "Fuck";
 6 };
 7 
 8 int main()
 9 {
10     A a;
11     A b(std::move(a));
12     cout << a.p << " " << a.str << " ";
13     cout << b.p << " "<<b.str << " ";
14     system("pause");
15 }