拷贝构造函数

我们知道，在C++中每一个类都有一个默认的构造函数，析构函数和拷贝构造函数。

 

对于两个对象p1,p2，实现语句p2 = p1就相当于在调用默认的拷贝构造函数，把p1对象的每个属性值逐个复制给对象p2的每个属性。所以拷贝构造函数主要用于对象之间的相互赋值。

 

当然，对于拷贝构造函数我们可以自定义，一般形式如下：

 

[cpp]  view plain copy

1. class_name(const class_name &object)  
2. {  
3.       
4. }  

 

这里我们可以看出拷贝构造函数的参数是const引用类型的，用const是为了更加安全，防止对象被更改，而这里是

必须要用引用类型的，如果不用会导致无穷递归，因为将对象的实参传递给形参要调用一次复制构造,但是这次调用

同样需要一次复制构造,所以就递归了。

至于调用拷贝构造函数，我们可以分两种情况调用：显式调用和隐式调用。下面通过Point类的例子来说明。

 

[cpp]  view plain copy

1. #include <iostream>  
2. #include <string.h>  
3. #include <stdio.h>  
4.   
5. using namespace std;  
6.   
7. class Point  
8. {  
9.     private:  
10.         int x,y;  
11.     public:  
12.         Point(int x,int y)  
13.         {  
14.             this->x = x;  
15.             this->y = y;  
16.         }  
17.         //拷贝构造函数  
18.         Point(const Point &t)  
19.         {  
20.             x = 2 * t.x;  
21.             y = 2 * t.y;  
22.         }  
23.         void Print()  
24.         {  
25.             cout<<x<<" "<<y<<endl;  
26.         }  
27. };  
28.   
29. int main()  
30. {  
31.     Point p1(10,20);  
32.     //Point p2(p1);  //显式调用拷贝构造函数  
33.     Point p2 = p1;   //隐式调用拷贝构造函数  
34.     p1.Print();  
35.     p2.Print();  
36.     return 0;  
37. }  

 

在拷贝的过程中，实际上大体分为两类：深拷贝和浅拷贝。

 

对于一般的变量来说，它们之间的赋值就是浅拷贝，如上面的程序中的拷贝。而对于动态数据成员，简单的浅拷贝是不行的，因为简单的浅拷贝只是单纯的赋值。对于有动态数据成员如果进行浅拷贝，对于动态数据成员这部分，它并没有重新分配空间，而是简单的把对应的变量指向原来被拷贝的对象的动态数据成员的空间，这样就会出现一个问题，在调用析构函数时主观上会进行两次回收空间，而实际上空间只有一块。

 

首先我们来明确一个事实：指针之间的赋值只是存储空间多了一个别名。

 

[cpp]  view plain copy

1. #include <iostream>  
2. #include <string.h>  
3. #include <stdio.h>  
4.   
5. using namespace std;  
6.   
7. class Point  
8. {  
9.     private:  
10.         int x,y;  
11.     public:  
12.         Point(int x,int y)  
13.         {  
14.             this->x = x;  
15.             this->y = y;  
16.         }  
17.         void reSet(int x,int y)  
18.         {  
19.             this->x = x;  
20.             this->y = y;  
21.         }  
22.         //拷贝构造函数  
23.         Point(const Point &t)  
24.         {  
25.             x = 2 * t.x;  
26.             y = 2 * t.y;  
27.         }  
28.         void Print()  
29.         {  
30.             cout<<x<<" "<<y<<endl;  
31.         }  
32. };  
33.   
34. int main()  
35. {  
36.     Point *p1 = new Point(40,50);  
37.     Point *p2 = p1;  
38.     p1->reSet(40,10);  
39.     p1->Print();  
40.     p2->Print();  
41.     return 0;  
42. }  

执行上面的程序，我们发现输出是：

 

 

得到这个结果是应该的，因为对于指针变量p1和p2都指向同一块内存空间。那么我们只要改变一个变量的值，那么另一个也会改变。

 

 

那么如果我们把主函数内改为：

 

[cpp]  view plain copy

1. int main()  
2. {  
3.     Point p1(40,50);  
4.     Point p2 = p1;  
5.     p1.reSet(40,10);  
6.     p1.Print();  
7.     p2.Print();  
8.     return 0;  
9. }  

结果为：

 

 

这样可以看出对变量p1的修改不影响p2的值。

 

所以对于动态数据成员，进行深拷贝的时候，要重新分配额外的空间。如下操作：

 

[cpp]  view plain copy

1. #include <iostream>  
2. #include <string.h>  
3. #include <stdio.h>  
4.   
5. using namespace std;  
6.   
7. class Student  
8. {  
9.     private:  
10.         char *name;  
11.         int age;  
12.         int id;  
13.     public:  
14.         Student(char *name,int age,int id)  
15.         {  
16.             this->name = new char[strlen(name) + 1];  
17.             strcpy(this->name,name);  
18.             this->age = age;  
19.             this->id = id;  
20.         }  
21.         //深拷贝  
22.         Student(const Student &t)  
23.         {  
24.             name = new char[strlen(t.name) + 1];  
25.             strcpy(name,t.name);  
26.             age = t.age;  
27.             id = t.id;  
28.         }  
29.         void Print()  
30.         {  
31.             cout<<name<<" "<<age<<" "<<id<<endl;  
32.         }  
33. };  
34.   
35. int main()  
36. {  
37.     Student s1("Jack",21,1);  
38.     Student s2(s1);  
39.     s1.Print();  
40.     s2.Print();  
41.     return 0;  
42. }