一文搞定移动语义和完美转发

以你之姓@ 2022-11-29 12:54 202阅读 0赞

### 一文搞定移动语义和完美转发 ###

#### 浅拷贝和深拷贝 ####

简单的区分： 浅拷贝：按字节拷贝，如果是指针变量则直接对指针地址进行拷贝 深拷贝：对内容进行拷贝，如果有指针变量则另外申请地址拷贝所指内容

写c++类时，如果类中有指针成员的话，通常我们都会格外注意，要注意拷贝构造函数的编写，因为如果简单的浅拷贝可能导致free一块未定义区域，是非法的。

如下面的程序：

#include<iostream>
    using namespace std;
    class HasPtrMem
    {
        
    public:
        HasPtrMem() :p(new int(0)) {
        }
        HasPtrMem(const HasPtrMem& h) :p(h.p) {
        }
        ~HasPtrMem() {
         delete p; }
        int* p;
    };
    
    int main()
    {
        
        HasPtrMem a;
        HasPtrMem b(a);
        cout << *a.p << endl;
        cout << *b.p << endl;
    }

构造函数申请了一块堆空间，而析构函数对该空间进行释放。在拷贝构造函数中，执行了浅拷贝，这会引发一个非常严重的问题：a的p申请了一块区域，对b执行了拷贝构造，则b的p指向了同一块区域，因此当程序执行结束时，a和b将纷纷执行其析构函数，假设a先执行其析构函数，则a将所指的区域进行了释放，那么释放后b的指针所指向的区域就成为了非法内存区域，即成为了dangling pointer 悬挂指针，对悬挂指针执行free释放内存将导致严重错误。

因此，通常我们会采用深拷贝的方法解决该问题：

#include<iostream>
    using namespace std;
    class HasPtrMem
    {
        
    public:
        int* p;
        HasPtrMem() :p(new int(0)) {
        }
        HasPtrMem(const HasPtrMem& h) :p(new int(*h.p)){
        }  //将拷贝构造函数改成深拷贝，重新申请一块堆上的内存，然后用h.p进行初始化
        ~HasPtrMem() {
         delete p; }
    };
    
    int main()
    {
        
        HasPtrMem a;
        HasPtrMem b(a);
        cout << *a.p << endl;
        cout << *b.p << endl;
    }

通过深拷贝，便可以解决浅拷贝的问题。使用深拷贝时，另外申请了一块区域并通过需要拷贝的对象的内容进行初始化，也就是其实指向的是不同的区域，只是内容相同。

看样子深拷贝完美解决了该问题，但是事实上确实这么完美吗？

#### 移动语义 ####

拷贝构造函数为指针成员进行内容拷贝的做法几乎是完美的，但是有些情况下该方法还是较为繁琐。下面的例子将说明：

#include<iostream>
    using namespace std;
    static int n_cstr;  //记录初始化次数
    static int n_dstr;   //记录析构次数
    static int n_cptr;   //记录拷贝构造函数次数
    class HasPtrMem
    {
        
    public:
        int* p;
        HasPtrMem() :p(new int(0))
        {
        
            cout << "construct:" << ++n_cstr << endl;  // 输出construct以及构造的次数，并且将次数+1
        }
        HasPtrMem(const HasPtrMem& h) :p(new int(*h.p))
        {
        
            cout << "copy construct:" << ++n_cptr << endl;  //输出copy construct以及拷贝的次数，将次W数+1
        }
        ~HasPtrMem()
        {
        
            delete p;
            cout << "destruct:" << ++n_dstr << endl;  //输出destruct并且析构的次数，将次数+1
        }
    };
    HasPtrMem gettemp()  //构造一个HasPtrMem并返回
    {
        
        HasPtrMem a = HasPtrMem();
        cout << a.p << endl;  //输出a的p所指的地址信息
        return a;
    }
    int main()
    {
        
        HasPtrMem b=gettemp();
        cout << b.p << endl;  //输出b的p所指的地址信息
    }

**(Tips:现代编译器有诸多优化的方向，如果让gettemp直接返回一个HasPtMem()的话，编译器将不构造它，直到赋值给b时直接为b构建，此段代码具有普适性)**

分析该代码：

gettemp()函数是产生一个HasPtrMem并输出地址后返回，写的是 深拷贝，因此将直接对内容进行拷贝，也就是预期是b的指针是指向另外申请的一块区域。

输出结果：

construct:1
    00F54E70
    copy construct:1
    destruct:1
    00F54EA0
    destruct:2

说明b执行了一次拷贝构造函数，将内容进行了复制，从两个指针指向的区域不同可以看出是另外申请了一块区域。

仔细想想，这次拷贝真的是有必要的吗？如果只是利用返回值进行一个赋值操作而已，那么拷贝构造函数申请了一个新的区域，将原来的内容拷贝过来，但是之后就会对临时变量的区域进行了析构。那么，如果这个指针指向的堆内存是非常大的，那么这一次的拷贝花销还是比较大的。

既然之后也不会用到a的p所指区域，那么如果能够直接将原来的内存给b，那么就会省去这次拷贝操作，会非常的提高效率。

这便是**移动构造函数**所做的事情。这个行为称为“**移动语义**”

利用移动构造函数后原程序：

#include<iostream>
    using namespace std;
    static int n_cstr;  //记录初始化次数
    static int n_dstr;   //记录析构次数
    static int n_cptr;   //记录拷贝构造函数次数
    class HasPtrMem
    {
        
    public:
        int* p;
        HasPtrMem() :p(new int(0))
        {
        
            cout << "construct:" << ++n_cstr << endl;  // 输出construct以及构造的次数，并且将次数+1
        }
        HasPtrMem(const HasPtrMem& h) :p(new int(*h.p))
        {
        
            cout << "copy construct:" << ++n_cptr << endl;  //输出copy construct以及拷贝的次数，将次W数+1
        }
        HasPtrMem(HasPtrMem&& h) :p(h.p) 
        {
        
            h.p = nullptr; 
            cout << "Move construct" << endl; 
        }
        ~HasPtrMem()
        {
        
            delete p;
            cout << "destruct:" << ++n_dstr << endl;  //输出destruct并且析构的次数，将次数+1
        }
    };
    HasPtrMem gettemp()  //构造一个HasPtrMem并返回
    {
        
        HasPtrMem a = HasPtrMem();
        *a.p = 10;
        cout << a.p << endl;  //输出
        return a;
    }
    int main()
    {
        
        HasPtrMem b(gettemp());
        cout << b.p << endl;  //输出b的p所指的地址信息
    }

运行结果：

construct:1
    013EC630
    Move construct
    destruct:1
    013EC630
    destruct:2

移动构造的输入是一个**右值引用**(下面会详讲)，行为是将h的p直接赋值给了主体的p，然后将h的p赋值为nullptr，这样之后h调用析构函数时也将不去释放任何内存，从而实现了一个内容的“窃取”。 需要注意的是一定要将原来的指针赋为空，否则原来的对象析构时将导致现在的指针悬挂。

分析结果需要注意两个p的地址是相同的，因此是符合预期的。相较于直接深拷贝，移动语义省去了申请新内存区域和拷贝内容以及释放一块内存区域。

也就是说，**移动语义实现了从一个对象到另一个对象的资源转移的过程！**

最基础的内容就是这样，之后将详将右值引用以及关于移动语义完美转发的更多细节。【这一部分还是比较抽象的，挺难】

#### 右值引用 ####

c语言中常说左值、右值。通常，通常认为左值是变量，右值是一个计算式。通常，我们这样区分，**可以取地址的、有名字的就是左值，不能取地址、没有名字的就是右值。** 例如在 a=b+c 式子中，a就是一个左值，(b+c)就是一个右值。

在C++11中，右值通常是两个概念：**将亡值(将要被移动的对象，包括返回右值引用 T&&)的函数返回值、std::move的返回值等 纯右值(一些运算表达式的值、非引用返回的函数返回的临时变量等)**

所谓的右值引用，就是必须绑定到右值的引用，通常用 &&获得右值引用，因此，右值引用通常只能绑定到一个将要销毁的对象，因此，可以自由地将一个右值引用的资源移动到另一个资源而不受影响(因为之后不会再对原资源进行任何操作，除了析构释放)

右值引用只是某个对象的另一个名字而已，可以将右值引用绑定到表达式上，但不能将一个右值引用直接绑定到一个左值上

**对于返回非引用类型的函数，可以将一个const的左值引用或者一个右值引用绑定到这样的表达式**

右值引用只能绑定到临时对象，这意味着所引用的对象将要被销毁并且该对象没有其他用户，因此使用右值引用的代码可以自由接管所引用对象的资源

**【常量左值引用是一个万金油！无论左值还是右值，常量还是非常量，都可以进行绑定，因此如果移动构造函数不符合，那么也至少可以执行拷贝构造函数】**

*  常量左值引用：全能类型，常用于拷贝语义
 *  非常量右值引用：用于移动语义和完美转发

void doWork(TYPE&& param) {
        
    	// ops and expressions using std::move(param)
    }

param是左值还是右值？param是一个左值。左值和右值与类型是没有关系的，即`int`既可以是左值，也可以是右值。区别左值和右值的唯一方法就是其定义，即**能否取到地址**。在这里，我们明显可以对`param`进行取地址操作，所以它是一个左值。也就是说，但凡有名字的“右值”，其实都是左值。

##### move函数 #####

首先需要记住，**move函数不move任何东西，它唯一的作用，就是将一个左值强制转换为右值引用**，继而就可以通过右值引用使用该值，以用于移动语义。不过，被转化的左值生命期没有因为左右值的变化而发生变化。

需要注意，被转化为右值后的值将不再使用，通常转换为右值的对象是一个声明周期快结束的对象。

int &&rr=std::move(rr1);  //it is right
    //写这个意味着，除了对rr1赋值或者销毁它之外，将不再使用它

使用move函数应该使用std::move，避免潜在的名字冲突。

> 实际上，为了保证移动语义的正确传递，程序员编写移动构造函数时，应该总是使用std::move转换拥有形如堆内存、文件句柄等资源的成员为右值，这样如果成员支持移动构造的话便可以轻松实现移动语义，哪怕成员没有移动构造函数，也至少将调用接收常量左值的构造函数实现拷贝构造，也不会出现问题。

#### 拷贝构造和移动语义 ####

通常实现时，实现一个接收const左值引用的拷贝构造函数，一个接收指向非const的右值引用的移动构造函数。

#include<iostream>
    using namespace std;
    static int n_cstr;  //记录初始化次数
    static int n_dstr;   //记录析构次数
    static int n_cptr;   //记录拷贝构造函数次数
    class HasPtrMem
    {
        
    public:
        int* p;
        HasPtrMem() :p(new int(0))
        {
        
            cout << "construct:" << ++n_cstr << endl;  // 输出construct以及构造的次数，并且将次数+1
        }
        HasPtrMem(const HasPtrMem& h) :p(new int(*h.p))
        {
        
            cout << "copy construct:" << ++n_cptr << endl;  //输出copy construct以及拷贝的次数，将次W数+1
        }
        HasPtrMem(HasPtrMem&& h) :p(h.p) 
        {
        
            h.p = nullptr; 
            cout << "Move construct" << endl; 
        }
        ~HasPtrMem()
        {
        
            delete p;
            cout << "destruct:" << ++n_dstr << endl;  //输出destruct并且析构的次数，将次数+1
        }
    };

采用上面的这个类，

int main()
    {
        
        HasPtrMem a;
        cout << a.p << endl;
        HasPtrMem b(a);
        cout << b.p << endl;  //输出b的p所指的地址信息
    }
    /* 
    运行结果：  调用了copy函数
    construct:1
    00774E70
    copy construct:1
    00774EA0
    destruct:1
    destruct:2
    */

可以看到调用了拷贝构造函数，地址是不同的。

int main()
    {
        
        HasPtrMem a;
        cout << a.p << endl;
        HasPtrMem b(std::move(a));
        cout << b.p << endl;  //输出b的p所指的地址信息
    }
    /*
    运行结果：   调用了move函数
    construct:1
    0157D9E8
    Move construct
    0157D9E8
    destruct:1
    destruct:2
    */

而通过move函数，将a转换为一个右值，从而调用了移动拷贝。

但是，如果a是一个const对象，那么会发生什么？

int main()
    {
        
        const HasPtrMem a;
        cout << a.p << endl;
        HasPtrMem b(std::move(a));
        cout << b.p << endl;  //输出b的p所指的地址信息
    }
    /*运行结果
    construct:1
    011F4E70
    copy construct:1
    011F4EA0
    destruct:1
    destruct:2
    */

可以看到调用了copy拷贝构造函数，也就是说，哪怕用了move也不一定是会调用移动语义的，如果move的对象不是const那么将调用移动语义，否则仍是拷贝构造，因为移动构造会改变对象的内容，而const是拒绝改变的，因此会直接采用copy。

#### 理解std::move和std::forward ####

这一部分的核心是：

*  **std::move执行一个无条件的对rvalue的转化。对其本身而言，它不move任何东西，只是强制转化为右值**
 *  **std::forward在参数被绑定为rvalue的情况下才会将它转化为rvalue**
 *  **std::move和std::forward在runtime是什么都不做的**

std::move是无条件地将其参数转化为一个右值，std::forward当特定条件满足时才会执行它的转换。

std::move的一个简洁实现方式：

template<typename T>
    typename remove_reference<T>::type&&
    move(T&& param)
    {
        
    	using ReturnType=typename remove_reference<T>::type&&;
    	return static_cast<ReturnType> (param);
    }

std::move实现时首先在 T上执行一个std::remove\_reference，它去除T身上的引用，保证&&应用到了一个非引用类型上，确保返回的是右值引用。

首先还是需要注意，用了move确实会返回右值，但是如果原来的参数是const类型，则返回的也是const 右值引用，是不会和移动语义所匹配的，不过，由于const 左值引用具有万金油属性，所以会匹配到左值引用上去，从而实现一个拷贝构造。**因此，如果想对这些对象执行move操作，就不要把它们声明为const，对const对象的move请求通常会悄悄的执行到copy操作上。**

对于std::forward,只有当它的参数被一个lvalue初始化时，才会进行cast即转化操作。`std::forward<T>()`与`std::move()`相区别的是，`move()`会无条件的将一个参数转换成右值，而`forward()`则会保留参数的左右值类型

#### 区分通用引用和右值引用 ####

通用引用（universal reference）。构成通用引用有两个条件：

1.  必须满足`T&&`这种形式
2.  类型`T`必须是通过推断得到的

看这段代码：

template <typename T>
    class TestClass {
        
    	public:
    		void func(T&& t) {
        } 
    }

因为T在初始化时已经知道是什么类型，所以不是推断得到是，是一个右值引用。

可以构成通用引用的有如下几种可能：

*  函数模板参数（function template parameters）
    
        template <typename T>
         void f(T&& param);
 *  `auto`声明（auto declaration）
    
        auto && var = ...;
 *  `typedef`声明（typedef declaration）
 *  `decltype`声明（decltype declaration）

**对于通用引用来说，传进来的如果是左值引用那就是左值引用，如果是右值引用那就是右值引用，因此是实现forward的一个很好的方式**

> 需要记住的东西：
> 
> 如果一个函数的template parameter有着T&&d 格式，且有一个deduce type T。或者一个对象被声明为 auto &&,那么这个parameter或者object就是一个通用引用
> 
> 如果type的声明的格式不完全是type &&，或者type deduction没有发生，那么type &&表示的是一个rvalue reference
> 
> 对于通用引用来说，传进来的如果是左值引用那就是左值引用，如果是右值引用那就是右值引用