C++11 新特性 移动语义

C++11支持移动语义。

一：为什么需要移动语义和什么是移动语义

我们先来看看C++11之前的复制过程。假设有下列代码：

vector<string> v1(1000000);//v1存放着100W个string,假设每个string长度为1000

vector<string> v2(v1);//使用v1初始化v2

vector和string类都使用动态内存分配，因此他们必须定义使用他们自己的new版本的复制构造函数。

复制构造函数vector<string>将使用new给1000W个string分配对象，而每个string 将使用new给每个string分配1000个字符的空间大小。接下来全部的都将从v1中逐个复制string到v2中，这里的工作量非常大，但是并没有问题。

但真的没有问题吗？有时候答案是否定的。例如，假设有一个函数，他返回一个vector<string>对象。

vector<string>copyVector(const vector<string> &v){

vector<string> temp;

//复制100W个string到temp

return temp;

}

接下来，以以下方式调用这个函数。

vector<string> v1(1000000);//v1存放着100W个string,假设每个string长度为1000

vector<string> v2=copyVector(v1);//使用v1初始化v2

构造v2的时候，编译器先利用v1构造生成了一个temp副本，然后将temp复制给一个临时对象，返回给v2,v2利用该临时对象，构造自己。

这将导致非常巨大的工作量！做了大量的无用功(将temp复制给一个临时对象，返回给v2,v2利用该临时对象，构造自己)。在这之后，temp这个临时的对象被删除了，返回的那个temp副本临时对象也被删除了，如果编译器能够将temp的所有权直接转移给v2不是更好吗？也就是说，不用将100W个string多次复制到新的地方，再删除原来的字符，而是直接保留字符，并将v2与之关联。这类似于计算机中文件的移动。实际文件还保留在原来的地方，而只是记录修改了，这种方法称之为移动语义。

移动语义避免了移动原始数据，而只是修改了记录。

要实现移动语义，必须让编译器知道什么时候需要复制，什么时候不需要复制。这就是右值引用发挥最大作用的地方。

二：如何实现移动语义

看一个简单的使用移动语义的例子。

[cpp]  view plain copy print ?

1. #include <iostream>  
2. using namespace std;  
3. class A{  
4. private:  
5.     int data;//data  
6.     int *pi;//point to data  
7. public:  
8.     //禁止隐式转换  
9.     A(){  
10.     }  
11.     explicit A(int i):data(i){  
12.         cout<<"normal constuctor1!"<<endl;    
13.         pi=&data;  
14.     }  

[cpp]  view plain copy print ?

1.     A(const A &a){  
2.         data=a.data;  
3.         cout<<"copy constructor!"<<endl;  
4.         pi=&data;  
5.     }  
6.       
7.     A(A &&a){  
8.         cout<<"move constructor!"<<endl;  
9.         //直接移动a.pi到pi  
10.         pi=a.pi;  
11.         //修改源pi  
12.         a.pi=nullptr;  
13.         a.data=0;  
14.     }  
15.     //A(A &&a)=delete;  
16.     A operator+(const A &a){  
17.         A temp(data+a.data);  
18.         cout<<endl<<"operator+ called!show temp!"<<endl;  
19.         temp.show();  
20.         cout<<endl;  
21.         return temp;  
22.     }  
23.     void show()const{  
24.         cout<<"pi="<<pi<<"   data="<<data<<endl;  
25.     }  
26. };  
27. int main(){  
28.     int i=99;  
29.     A a(10);  
30.     a.show();  
31.     A b(i);  
32.     b.show();  
33.     A c(b);  
34.     c.show();  
35.     A d(b+c);  
36.     cout<<"show d!"<<endl;  
37.     d.show();  
38.       
39.       
40. }  

看出来什么问题没有?

对,好像并没有调用移动构造函数!

但是有没有发现!temp和d的pi都是指向同一个地方那个?这是什么情况?

原来是因为GCC自带的右值语义!

也就是,编译器GCC会帮你自动优化!

不信请看下面例子!我们利用C++11的delete特性!

[cpp]  view plain copy print ?

1. #include <iostream>  
2. using namespace std;  
3. class A{  
4. private:  
5.     int data;//data  
6.     int *pi;//point to data  
7. public:  
8.     //禁止隐式转换  
9.     A(){  
10.     }  
11.     explicit A(int i):data(i){  
12.         cout<<"normal constuctor1!"<<endl;    
13.         pi=&data;  
14.     }  
15.     A(const A &a){  
16.         data=a.data;  
17.         cout<<"copy constructor!"<<endl;  
18.         pi=&data;  
19.     }  
20.     /* 
21.     A(A &&a){ 
22.         cout<<"move constructor!"<<endl; 
23.         //直接移动a.pi到pi 
24.         pi=a.pi; 
25.         //修改源pi 
26.         a.pi=nullptr; 
27.         a.data=0; 
28.     }*/  
29.     A(A &&a)=delete;  
30.     A operator+(const A &a){  
31.         A temp(data+a.data);  
32.         cout<<endl<<"operator+ called!show temp!"<<endl;  
33.         temp.show();  
34.         cout<<endl;  
35.         return temp;  
36.     }  
37.     void show()const{  
38.         cout<<"pi="<<pi<<"   data="<<data<<endl;  
39.     }  
40. };  
41. int main(){  
42.     int i=99;  
43.     A a(10);  
44.     a.show();  
45.     A b(i);  
46.     b.show();  
47.     A c(b);  
48.     c.show();  
49.     A d(b+c);  
50.     cout<<"show d!"<<endl;  
51.     d.show();  
52.       
53.       
54. }  

运行结果:

也就是说,在return temp;这一句上将要调用A(A&&)这个构造函数;

但是现在这个函数被我们显式删除了!

b+c也是一个右值!也是需要调用移动构造函数的!

因此上一个例子实际上是调用了移动语义的构造函数!