可拷贝和可移动的概念

在面向对象中，有的类是可以拷贝的，例如车、房等他们的属性是可以复制的，可以调用拷贝构造函数，有点类的对象则是独一无二的，或者类的资源是独一无二的，比如 IO 、 std::unique_ptr等，他们不可以复制，但是可以把资源交出所有权给新的对象，称为可以移动的。
C++11最重要的一个改进之一就是引入了move语义，这样在一些对象的构造时可以获取到已有的资源（如内存）而不需要通过拷贝，申请新的内存，这样移动而非拷贝将会大幅度提升性能。例如有些右值即将消亡析构，这个时候我们用移动构造函数可以接管他们的资源。

移动构造函数和移动赋值函数

考虑这样一个类A，里面的成员i 具有一个500的堆数组

#include <iostream>
#include <cstring>

using namespace  std;

class A{
public:
   A():i(new int[500]){
      cout<<"class A construct!"<<endl;
   }
   A(const A &a):i(new int[500]){
      memcpy(i, a.i,500*sizeof(int));
      cout<<"class A copy!"<<endl;
   }
   ~A(){
      delete []i;
      cout<<"class A destruct!"<<endl;
   }

private:
   int *i;
};

A get_A_value(){
    return A();
}
void pass_A_by_value(A a){

}
int main(){
    A a = get_A_value();
    return 0;
}

编译时为了看到临时对象拷贝我们关闭了编译器省略复制构造的优化

g++ main.cpp -o main.exe -fno-elide-constructors -std=c++11

运行时可以看到

class A construct!
class A copy!
class A destruct!
class A copy!
class A destruct!
class A destruct!

发生了一次构造和两次拷贝！在每次拷贝中数组都得重新申请内存，而被拷贝后的对象很快就会析构，这无疑是一种浪费。
我们在类中加上移动构造函数:

...
#include <iostream>
   A(A &&a)noexcept
     :i(a.i)
   {
      a.i = nullptr;
      cout<< "class A move"<<endl;
   }
...

然后编译、执行；可以看到输出为

class A construct!
class A move
class A destruct!
class A move
class A destruct!
class A destruct!

原先的两次构造变成了两次移动！！在移动构造函数中，我们做了什么呢，我们只是获取了被移动对象的资源（这里是内存）的所有权，同时把被移动对象的成员指针置为空（以避免移动过来的内存被析构），这个过程中没有新内存的申请和分配，在大量对象的系统中，移动构造相对与拷贝构造可以显著提高性能！这里noexcept告诉编译器这里不会抛出异常，从而让编译器省一些操作(这个也是保证了STL容器在重新分配内存的时候（知道是noexpect）而使用移动构造而不是拷贝构造函数)，通常移动构造都不会抛出异常的。

@note: 这里仅仅为了演示，用 -fno-elide-constructions 关闭了g++编译器会省略函数返回值时临时对象的拷贝的优化。虽然编译器很多时候可以为我们进行优化，有些时候编译器优化不了的还是需要了解和运用移动语义的。

除了移动构造函数，移动赋值运算符应该一并给写出来。

   A &operator =(A &&rhs) noexcept{
      // check self assignment
      if(this != &rhs){
         delete []i;
         i = rhs.i;
         rhs.i = nullptr;
      }
      cout<< "class A move and assignment"<<std::endl;
      return *this;
   }

小结移动构造和移动赋值

小结一下移动构造函数和移动赋值函数的书写要诀：

1. 偷梁换柱直接“浅拷贝”右值引用的对象的成员；
2. 需要把原先右值引用的指针成员置为 nullptr,以避免右值在析构的时候把我们浅拷贝的资源给释放了;
3. 移动构造函数需要先检查一下是否是自赋值，然后才能先delet自己的成员内存再浅拷贝右值的成员，始终记住第2条。

关于构造函数这部分有很多best practice ：搜索“三五法则”、 “copy and swap”、 "move and swap" 了解详情

std::move()

std::move(lvalue) 的作用就是把一个左值转换为右值。关于左右值的含义我们上一篇博客C++11的右值引用进行过阐述。

int lv = 4;
int &lr = lv;// 正确，lr是l的左值引用
int &&rr = lv; // 错误，不可以把右值引用绑定到一个左值

如果使用std::move 函数

   int &&rr = std::move(lv);  // 正确，把左值转换为右值 

可以看到 std::move的作用是把左值转换为右值的。

让我们看一看 std::move 的源码实现：

// FUNCTION TEMPLATE move
template <class _Ty>
_NODISCARD constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept { // forward _Arg as movable
    return static_cast<remove_reference_t<_Ty>&&>(_Arg);
}

可以看到std::move 是一个模板函数，通过remove_\reference_t获得模板参数的原本类型，然后把值转换为该类型的右值。用C++大师 Scott Meyers 的在《Effective Modern C++》中的话说， std::move 是个cast ，not a move.

值得注意的是： 使用move意味着，把一个左值转换为右值，原先的值不应该继续再使用（承诺即将废弃）

使用 std::move 实现一个高效的 swap 函数

我们可以使用 move语义实现一个 交换操作，swap;
在不使用 Move 语义的情况下

swap(A &a1, A &a2){
    A tmp(a1); // 拷贝构造函数一次，涉及大量数据的拷贝
    a1 = a2;   // 拷贝赋值函数调用，涉及大量数据的拷贝
    a2 = tmp;  // 拷贝赋值函数调用，涉及大量数据的拷贝
}

如果使用 Move语义，即加上移动构造函数和移动赋值函数：

void swap_A(A &a1, A &a2){
    A tmp(std::move(a1)); // a1 转为右值，移动构造函数调用，低成本
    a1 = std::move(a2);   // a2 转为右值，移动赋值函数调用，低成本
    a2 = std::move(tmp);  // tmp 转为右值移动给a2
}

可以看到move语义确实可以提高性能，事实上， move语义广泛地用于标准库的容器中。C++11标准库 里的std::swap 也是基于移动语义实现的。

说到了 swap, 那就不得不说一下啊 move-and-swap 技术了

Move and swap 技巧

看下面一段代码，实现了一个 unique_ptr ,和标准的std::unqiue_ptr的含义一致，智能指针的一种。

template<typename T>
class unique_ptr
{
    T* ptr;

public:

    
    explicit unique_ptr(T* p = nullptr)
    {
        ptr = p;
    }

    ~unique_ptr()
    {
        delete ptr;
    }
    
    // move constructor
    unique_ptr(unique_ptr&& source)   // note the rvalue reference
    {
        ptr = source.ptr;
        source.ptr = nullptr;
    }
    
 /*    unique_ptr& operator=(unique_ptr&& source)   // 这里使用右值引用
    {
        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 and swap  idiom replace the move assignment operator
    unique_ptr& operator=(unique_ptr rhs)   // 这里不用引用，会调用移动构造函数
    {
        std::swap(ptr, rhs.ptr);
        // std::swap(*this,rhs)  // is also ok
        return *this;
    }
    
    
    
    T* operator->() const
    {
        return ptr;
    }

    T& operator*() const
    {
        return *ptr;
    }
};

在这里如果要按照常规办法写移动赋值函数，函数体内需要写一堆检查自赋值等冗长的代码。使用 move-and-swap语义，只用简短的两行就可以写出来。 在移动赋值函数中 source 是个局部对象，这样在形参传递过来的时候必须要调用拷贝构造函数（这里没有实现则不可调用）或者移动构造函数
，（事实上仅限右值可以传进来了）。然后 std::swap 负责把原先的资源和source 进行交换，完成了移动赋值。这样写节省了很多代码，很优雅。