C++ 类的深拷贝与浅拷贝||深拷贝通过重载拷贝构造函数与重载赋值运算符实现

 

C++ 类的深拷贝与浅拷贝||深拷贝通过重载拷贝构造函数与重载赋值运算符实现

分类： C/C++读书笔记 2013-08-08 21:42  521人阅读  评论(0)  收藏  举报

C++ 对象 类 CC++ 笔试面试

在面向对象程序设计中，对象间的相互拷贝和赋值是经常进行的操作。
如果对象在申明的同时马上进行的初始化操作，则称之为拷贝运算。例如：

class1 A("Time"); 

class1 B=A;

此时其实际调用的是B(A)，拷贝构造函数。
如果对象在申明之后，在进行的赋值运算，我们称之为赋值运算。例如：

class1 A("Time"); 

class1 B;

B=A;
此时实际调用的类的缺省赋值函数B.operator=(A);
不管是拷贝构造函数还是赋值运算，其都有缺省的定义。也就是说，即使我们不overload这两种operation,仍然可以运行。一般，如果需要手动编写析构函数的类，都需要overload 拷贝构造函数和赋值运算符。
重载（overload)赋值运算符 
对于对象的域在heap上分配内存的情况，我们必须重载赋值运算符。当对象间进行拷贝的时候，我们必须让不同对象的成员域指向其不同的heap地址--如果成员域属于heap的话。
因此，重载赋值运算符后的代码如下：

[cpp]  view plain copy print ?

1. class A  
2. {  
3. public:  
4.     A()  
5.     {  
6.     }  
7.     A(int id,char *t_name)  
8.     {  
9.         _id=id;  
10.         name=new char[strlen(t_name)+1];  
11.         strcpy(name,t_name);  
12.     }  
13.       
14.     A& operator =(A& a)//注意：此处一定要返回对象的引用，否则返回后其值立即消失！  
15.     {  
16.         if(name!=NULL)  
17.                 delete name;  
18.         this->_id=a._id;  
19.         name=new char[strlen(a.name)+1];  
20.         strcpy(name,a.name);  
21.         return *this;  
22.     }  
23.   
24.     ~A()  
25.     {  
26.         cout<<"~destructor"<<endl;  
27.         delete name;  
28.     }  
29.   
30.     int _id;  
31.     char *name;  
32. };  
33.   
34. int main()  
35. {  
36.  A a(1,"http://blog.csdn.net/shihui512");  
37.  A b;  
38.  b=a;  
39. }  

在对象a,b退出相应的作用域，其调用相应的析构函数，然后释放分别属于不同heap空间的内存，程序正常结束。

类的深拷贝函数的重载

[cpp]  view plain copy print ?

1.  public class A  
2. {  
3.     public:  
4.         ...  
5.         A(A &a);//重载拷贝函数  
6.         A& operator=(A &b);//重载赋值函数  
7.         //或者 这样重载赋值运算符 void operator=(A &a);即不返回任何值。如果这样的话，将不能链式赋值 ，例如a=b=c  
8.     private:  
9.         int _id;  
10.         char *username;  
11. }  
12.   
13. A::A(A &a)  
14. {  
15.     _id=a._id;  
16.     username=new char[strlen(a.username)+1];  
17.     if(username!=NULL)  
18.         strcpy(username,a.usernam);  
19. }  
20.   
21. A& A::operaton=(A &a)  
22. {  
23.         if(this==&a)//  优化操作。  
24.             return *this;  
25.         if(username!=NULL)  
26.             delete username;  
27.         _id=a._id;  
28.         username=new char[strlen(a.username)+1];  
29.         if(username!=NULL)  
30.             strcpy(username,a.usernam);  
31.         return *this;      
32. }  

赋值运算符和拷贝函数很相似。只不过赋值函数最好有返回值（进行链式赋值），返回也最好是对象的引用， 而拷贝函数不需要返回任何。同时，赋值函数首先要释放掉对象自身的堆空间（如果需要的话），然后进行其他的operation.而拷贝函数不需要如此，因为对象此时还没有分配堆空间。

note1:
不要按值向函数传递对象。如果对象有内部指针指向动态分配的堆内存，丝毫不要考虑把对象按值传递给函数，要按引用传递。并记住：若函数不能改变参数对象的状态和目标对象的状态，则要使用const修饰符
note2:问题：
对于类的成员需要动态申请堆空间的类的对象，都最好要overload其赋值函数和拷贝函数。拷贝构造函数是没有任何返回类型的，这点毋庸置疑。 而赋值函数可以返回多种类型，例如以上讲的void,类本身，以及类的引用。
问，这几种赋值函数的返回各有什么异同？
答：
1 如果赋值函数返回的是void ，我们知道，其唯一一点需要注意的是，其不支持链式赋值运算，即a=b=c这样是不允许的！
2 对于返回的是类对象本身，还是类对象的引用，其有着本质的区别！
第一：如果其返回的是类对象本身。
A operator =(A& a)
{
    if(name!=NULL)
    delete name;
    this->_id=a._id;
    int len=strlen(a.name);
    name=new char[len+1];
    strcpy(name,a.name);
    return *this;

}

[cpp]  view plain copy print ?

1. A operator =(A& a)  
2. {  
3.     if(name!=NULL)  
4.     delete name;  
5.     this->_id=a._id;  
6.     int len=strlen(a.name);  
7.     name=new char[len+1];  
8.     strcpy(name,a.name);  
9.     return *this;  
10. }  

其过程是这样的：
class1 A("Time");
class1 B; 
B=A;
其所有的过程如下：
1 释放对象原来的堆资源
2 重新申请堆空间
3 拷贝源的值到对象的堆空间的值
4 创建临时对象（调用临时对象拷贝构造函数），将临时对象返回
5. 临时对象结束，调用临时对象析构函数，释放临时对象堆内存
但是，在这些步骤里面，如果第4步，我们没有overload 拷贝函数，也就是没有进行深拷贝。那么在进行第5步释放临时对象的heap 空间时，将释放掉的是和目标对象同一块的heap空间。这样当目标对象B作用域结束调用析构函数时，就会产生错误！！因此，如果赋值运算符返回的是类对象本身，那么一定要overload 类的拷贝构造函数（进行深拷贝）！
第二：如果赋值运算符返回的是对象的引用，
A& operator =(A& a)
{
    if(name!=NULL)
    delete name;
    this->_id=a._id;
    int len=strlen(a.name);
    name=new char[len+1];
    strcpy(name,a.name);
    return *this;
}
那么其过程如下：
1 释放掉原来对象所占有的堆空间
2 申请一块新的堆内存
3 将源对象的堆内存的值copy给新的堆内存
4 返回源对象的引用
5 结束。

因此，如果赋值运算符返回的是对象引用，那么其不会调用类的拷贝构造函数，这是问题的关键所在！！

一个类对象拷贝的简单例子。 

[cpp]  view plain copy print ?

1. #include <iostream>  
2. using namespace std;  
3. class CExample  
4. {  
5. private:  
6. 　int a;  
7. public:  
8. 　CExample(int b){ a=b;}  
9. 　void Show ()  
10. 　{  
11.     cout<<a<<endl;  
12.    }  
13. };  
14.   
15. int main()  
16. {  
17. 　CExample A(100);  
18. 　CExample B=A;  
19. 　B.Show ();  
20. 　return 0;  
21. }   

运行程序，屏幕输出100。从以上代码的运行结果可以看出，系统为对象B分配了内存并完成了与对象A的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。下面举例说明拷贝构造函数的工作过程。

[cpp]  view plain copy print ?

1. #include <iostream>  
2. using namespace std;  
3.   
4. class CExample  
5. {  
6.    private:  
7.    int a;  
8.    public:  
9.    CExample(int b){ a=b;}  
10.    CExample(const CExample& C){a=C.a;}  
11.    void Show ()  
12.    {  
13.     cout<<a<<endl;  
14.    }  
15. };  
16.   
17. int main()  
18. {  
19.   CExample A(100);  
20.   CExample B=A;  
21.   B.Show ();  
22.   return 0;  
23. }  

CExample(const CExample& C)就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X& x)。

当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。 以下情况都会调用拷贝构造函数：
一个对象以值传递的方式传入函数体 
一个对象以值传递的方式从函数返回 
一个对象需要通过另外一个对象进行初始化。 

如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝。 
自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。

浅拷贝和深拷贝 
在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。 深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。下面举个深拷贝的例子。

[cpp]  view plain copy print ?

1. #include <iostream>  
2. using namespace std;  
3. class CA  
4. {  
5. 　public:  
6. 　　CA(int b,char* cstr)  
7. 　　{  
8. 　　　a=b;  
9. 　　　str=new char[b];  
10. 　　　strcpy(str,cstr);  
11. 　　}  
12. 　　CA(const CA& C)  
13. 　　{  
14. 　　　a=C.a;  
15. 　　　str=new char[a]; //深拷贝  
16. 　　　if(str!=0)  
17. 　　　　strcpy(str,C.str);  
18. 　　}  
19. 　　void Show()  
20. 　　{  
21. 　　　cout<<str<<endl;  
22. 　　}  
23. 　　~CA()  
24. 　　{  
25. 　　　delete str;  
26. 　　}  
27. 　private:  
28. 　　int a;  
29. 　　char *str;  
30. };  
31.   
32. int main()  
33. {  
34. 　CA A(10,"Hello!");  
35. 　CA B=A;  
36. 　B.Show();  
37. 　return 0;  
38. }   

深拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源，但复制过程并未复制资源的情况视为浅拷贝。
浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错。 
Test(Test &c_t)是自定义的拷贝构造函数，拷贝构造函数的名称必须与类名称一致，函数的形式参数是本类型的一个引用变量,且必须是引用。 
当用一个已经初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用，如果你没有自定义拷贝构造函数的时候，系统将会提供给一个默认的拷贝构造函数来完成这个过程。

在某些状况下，类体内的成员是需要开辟动态开辟堆 内存的,如果不自定义拷贝构造函数而让系统自己处理，那么就会导致堆内存的所属权产生混乱，例如，已经开辟的一端堆地址原来是属于对象a的，由于复制过程发生，b对象取得是a已经开辟的堆地址，一旦程序产生析构，释放堆的时候，计算机是不可能清楚这段地址是真正属于谁的，当连续发生两次析构的时候 ，就出现了运行错误。拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源但复制过程并未复制资源的情况视为浅拷贝。
浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错,这点尤其需要注意！