C++移动构造函数以及move语句简单介绍

C++移动构造函数以及move语句简单介绍

首先看一个小例子：

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <vector>

using namespace std;

int main()
{
    string st = "I love xing";
    vector<string> vc ;
    vc.push_back(move(st));
    cout<<vc[0]<<endl;
    if(!st.empty())
        cout<<st<<endl;

    return 0;
}

 

结果为：

 

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <vector>

using namespace std;

int main()
{
    string st = "I love xing";
    vector<string> vc ;
    vc.push_back(st);
    cout<<vc[0]<<endl;
    if(!st.empty())
        cout<<st<<endl;

    return 0;
}

 

结果为：

 

这两个小程序惟一的不一样是调用vc.push_back()将字符串插入到容器中去时，第一段代码使用了move语句，而第二段代码没有使用move语句。输出的结果差别也很明显，第一段代码中，原来的字符串st已经为空，而第二段代码中，原来的字符串st的内容没有变化。

 

好，记住这两端代码的输出结果之间的差别。下面咱们简单介绍一下移动构造函数。

在介绍移动构造函数以前，咱们先要回顾一下拷贝构造函数。

咱们都知道，C++在三种状况下会调用拷贝构造函数（可能有纰漏），第一种状况是函数形实结合时，第二种状况是函数返回时，函数栈区的对象会复制一份到函数的返回去，第三种状况是用一个对象初始化另外一个对象时也会调用拷贝构造函数。

除了这三种状况下会调用拷贝构造函数，另外若是将一个对象赋值给另外一个对象，这个时候回调用重载的赋值运算符函数。

不管是拷贝构造函数，仍是重载的赋值运算符函数，我记得当时在上C++课的时候，老师再三强调，必定要注意指针的浅层复制问题。

这里在简单回忆一下拷贝构造函数中的浅层复制问题

首先看一个浅层复制的代码

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <vector>

using namespace std;

class Str{
    public:
    char *value;
    Str(char s[])
    {
        cout<<"调用构造函数..."<<endl;
        int len = strlen(s);
        value = new char[len + 1];
        memset(value,0,len + 1);
        strcpy(value,s);
    }
    Str(Str &v)
    {
        cout<<"调用拷贝构造函数..."<<endl;
        this->value = v.value;
    }
    ~Str()
    {
        cout<<"调用析构函数..."<<endl;
        if(value != NULL)
            delete[] value;
    }
};

int main()
{

    char s[] = "I love BIT";
    Str *a = new Str(s);
    Str *b = new Str(*a);
    delete a;
    cout<<"b对象中的字符串为："<<b->value<<endl;
    delete b;
    return 0;
}

 

输出结果为：

 

 

首先结果并不符合预期，咱们但愿b对象中的字符串也是I love BIT可是输出为空，这是由于b->value和a->value指向了同一片内存区域，当delete a的时候，该内存区域已经被收回，因此再用b->value访问那块内存其实是不合适的，并且，虽然我运行时程序没有崩溃，可是程序存在崩溃的风险呀，由于当delete b的时候，那块内存区域又被释放了一次，两次释放同一块内存，至关危险呀。

咱们用valgrind检查一下，发现，至关多的内存错误呀！

 

 

其中就有一个Invalid free 也就是删除b的时候调用析构函数，对已经释放掉对空间又释放了一次。

 

那么深层复制应该怎样写呢？

代码以下：

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <vector>

using namespace std;

class Str{
    public:
    char *value;
    Str(char s[])
    {
        cout<<"调用构造函数..."<<endl;
        int len = strlen(s);
        value = new char[len + 1];
        memset(value,0,len + 1);
        strcpy(value,s);
    }
    Str(Str &v)
    {
        cout<<"调用拷贝构造函数..."<<endl;
        int len = strlen(v.value);
        value = new char[len + 1];
        memset(value,0,len + 1);
        strcpy(value,v.value);
    }
    ~Str()
    {
        cout<<"调用析构函数..."<<endl;
        if(value != NULL)
        {
            delete[] value;
            value = NULL;
        }
    }
};

int main()
{

    char s[] = "I love BIT";
    Str *a = new Str(s);
    Str *b = new Str(*a);
    delete a;
    cout<<"b对象中的字符串为："<<b->value<<endl;
    delete b;
    return 0;
}

 

结果为：

 

 

此次达到了咱们预想的效果，并且，用valgrind检测一下，发现，没有内存错误！

 

 

 

因此，写拷贝构造函数的时候，切记要注意指针的浅层复制问题呀！

 

好的，回顾了一下拷贝构造函数，下面回到移动构造函数上来。

有时候咱们会遇到这样一种状况，咱们用对象a初始化对象b，后对象a咱们就不在使用了，可是对象a的空间还在呀（在析构以前），既然拷贝构造函数，实际上就是把a对象的内容复制一份到b中，那么为何咱们不能直接使用a的空间呢？这样就避免了新的空间的分配，大大下降了构造的成本。这就是移动构造函数设计的初衷。

下面这个图，很好地说明了拷贝构造函数和移动构造函数的区别。

 

 

看明白了吗？

通俗一点的解释就是，拷贝构造函数中，对于指针，咱们必定要采用深层复制，而移动构造函数中，对于指针，咱们采用浅层复制。

可是上面提到，指针的浅层复制是很是危险的呀。没错，确实很危险，并且经过上面的例子，咱们也能够看出，浅层复制之因此危险，是由于两个指针共同指向一片内存空间，若第一个指针将其释放，另外一个指针的指向就不合法了。因此咱们只要避免第一个指针释放空间就能够了。避免的方法就是将第一个指针（好比a->value）置为NULL，这样在调用析构函数的时候，因为有判断是否为NULL的语句，因此析构a的时候并不会回收a->value指向的空间（同时也是b->value指向的空间）

因此咱们能够把上面的拷贝构造函数的代码修改一下：

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <vector>

using namespace std;

class Str{
    public:
    char *value;
    Str(char s[])
    {
        cout<<"调用构造函数..."<<endl;
        int len = strlen(s);
        value = new char[len + 1];
        memset(value,0,len + 1);
        strcpy(value,s);
    }
    Str(Str &v)
    {
        cout<<"调用拷贝构造函数..."<<endl;
        this->value = v.value;
        v.value = NULL;
    }
    ~Str()
    {
        cout<<"调用析构函数..."<<endl;
        if(value != NULL)
            delete[] value;
    }
};

int main()
{

    char s[] = "I love BIT";
    Str *a = new Str(s);
    Str *b = new Str(*a);
    delete a;
    cout<<"b对象中的字符串为："<<b->value<<endl;
    delete b;
    return 0;
}

 

结果为：

 

 

修改后的拷贝构造函数，采用了浅层复制，可是结果仍可以达到咱们想要的效果，关键在于在拷贝构造函数中，最后咱们将v.value置为了NULL，这样在析构a的时候，就不会回收a->value指向的内存空间。

 

这样用a初始化b的过程当中，实际上咱们就减小了开辟内存，构形成本就下降了。

 

但要注意，咱们这样使用有一个前提是：用a初始化b后，a咱们就不须要了，最好是初始化完成后就将a析构。若是说，咱们用a初始化了b后，仍要对a进行操做，用这种浅层复制的方法就不合适了。

因此C++引入了移动构造函数，专门处理这种，用a初始化b后，就将a析构的状况。

 

*************************************************************

**移动构造函数的参数和拷贝构造函数不一样，拷贝构造函数的参数是一个左值引用，可是移动构造函数的初值是一个右值引用。（关于右值引用你们能够看我以前的文章，或者查找其余资料）。这意味着，移动构造函数的参数是一个右值或者将亡值的引用。也就是说，只用用一个右值，或者将亡值初始化另外一个对象的时候，才会调用移动构造函数。而那个move语句，就是将一个左值变成一个将亡值。

 

移动构造函数应用最多的地方就是STL中

给出一个代码，你们自行验证使用move和不适用move的区别吧

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <vector>
using namespace std;

class Str{
    public:
        char *str;
        Str(char value[])
        {
            cout<<"普通构造函数..."<<endl;
            str = NULL;
            int len = strlen(value);
            str = (char *)malloc(len + 1);
            memset(str,0,len + 1);
            strcpy(str,value);
        }
        Str(const Str &s)
        {
            cout<<"拷贝构造函数..."<<endl;
            str = NULL;
            int len = strlen(s.str);
            str = (char *)malloc(len + 1);
            memset(str,0,len + 1);
            strcpy(str,s.str);
        }
        Str(Str &&s)
        {
            cout<<"移动构造函数..."<<endl;
            str = NULL;
            str = s.str;
            s.str = NULL;
        }
        ~Str()
        {
            cout<<"析构函数"<<endl;
            if(str != NULL)
            {
                free(str);
                str = NULL;
            }
        }
};
int main()
{
    char value[] = "I love zx";
    Str s(value);
    vector<Str> vs;
    //vs.push_back(move(s));
    vs.push_back(s);
    cout<<vs[0].str<<endl;
    if(s.str != NULL)
        cout<<s.str<<endl;
    return 0;
} 

 

若是你以为对你有用，请咱一个吧~~~