C++ 拷贝构造函数

拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于：

通过使用另一个同类型的对象来初始化新创建的对象。
复制对象把它作为参数传递给函数。
复制对象，并从函数返回这个对象。

如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。

 1 #include <iostream>
 2  
 3 using namespace std;
 4  
 5 class Line
 6 {
 7    public:
 8       int getLength( void );
 9       Line( int len );             // 简单的构造函数
10       Line( const Line &obj);      // 拷贝构造函数
11       ~Line();                     // 析构函数
12  
13    private:
14       int *ptr;
15 };
16  
17 // 成员函数定义，包括构造函数
18 Line::Line(int len)
19 {
20     cout << "调用构造函数" << endl;
21     // 为指针分配内存
22     ptr = new int;
23     *ptr = len;
24 }
25  
26 Line::Line(const Line &obj)
27 {
28     cout << "111111111111111111111111111" << endl;
29     cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;
30     cout << "222222222222222222222222222" << endl;
31     ptr = new int;
32     *ptr = *obj.ptr; // 拷贝值
33 }
34  
35 Line::~Line(void)
36 {
37     cout << "释放内存" << endl;
38     delete ptr;
39 }
40 int Line::getLength( void )
41 {
42     return *ptr;
43 }
44  
45 void display(Line obj)  //如果是display(Line &obj)则不会调用拷贝
46 {
47    cout << "line 大小 : " << obj.getLength() <<endl;
48 }
49  
50 // 程序的主函数
51 int main( )
52 {
53    Line line(10);
54     cout << "--------------------" << endl;
55  
56    display(line);
57  
58     cout << "999999999999999999999" << endl;
59    return 0;
60 }

结果是

调用构造函数
--------------------
111111111111111111111111111
调用拷贝构造函数并为指针 ptr 分配内存
222222222222222222222222222
line 大小 : 10
释放内存
999999999999999999999
释放内存

稍作修改，通过使用已有的同类型的对象来初始化新创建的对象：

 1 #include <iostream>
 2  
 3 using namespace std;
 4  
 5 class Line
 6 {
 7    public:
 8       int getLength( void );
 9       Line( int len );             // 简单的构造函数
10       Line( const Line &obj);      // 拷贝构造函数
11       ~Line();                     // 析构函数
12  
13    private:
14       int *ptr;
15 };
16  
17 // 成员函数定义，包括构造函数
18 Line::Line(int len)
19 {
20     cout << "调用构造函数" << endl;
21     // 为指针分配内存
22     ptr = new int;
23     *ptr = len;
24 }
25  
26 Line::Line(const Line &obj)
27 {
28     cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;
29     ptr = new int;
30     *ptr = *obj.ptr; // 拷贝值
31 }
32  
33 Line::~Line(void)
34 {
35     cout << "释放内存" << endl;
36     delete ptr;
37 }
38 int Line::getLength( void )
39 {
40     return *ptr;
41 }
42  
43 void display(Line obj)
44 {
45    cout << "line 大小 : " << obj.getLength() <<endl;
46 }
47  
48 // 程序的主函数
49 int main( )
50 {
51    Line line1(10);
52    cout << "00000000000000000000000000" << endl;
53    Line line2 = line1; // 这里也调用了拷贝构造函数
54    cout << "11111111111111111111111111" << endl;
55    display(line1);
56    cout << "22222222222222222222222222" << endl;
57    display(line2);
58    cout << "33333333333333333333333333" << endl;
59    return 0;
60 }

结果是

调用构造函数
00000000000000000000000000
调用拷贝构造函数并为指针 ptr 分配内存
11111111111111111111111111
调用拷贝构造函数并为指针 ptr 分配内存
line 大小 : 10
释放内存
22222222222222222222222222
调用拷贝构造函数并为指针 ptr 分配内存
line 大小 : 10
释放内存
33333333333333333333333333
释放内存
释放内存   //最后这两个析构是line1和line2的

几个原则：

C++ primer p406 ：拷贝构造函数是一种特殊的构造函数，具有单个形参，该形参（常用const修饰）是对该类类型的引用。当定义一个新对象并用一个同类型的对象对它进行初始化时，将显示使用拷贝构造函数。当该类型的对象传递给函数或从函数返回该类型的对象时，将隐式调用拷贝构造函数。

C++支持两种初始化形式：

拷贝初始化 int a = 5; 和直接初始化 int a(5); 对于其他类型没有什么区别，对于类类型直接初始化直接调用实参匹配的构造函数，拷贝初始化总是调用拷贝构造函数，也就是说：

A x(2);　　//直接初始化，调用构造函数
A y = x;　　//拷贝初始化，调用拷贝构造函数

必须定义拷贝构造函数的情况：

只包含类类型成员或内置类型（但不是指针类型）成员的类，无须显式地定义拷贝构造函数也可以拷贝；有的类有一个数据成员是指针，或者是有成员表示在构造函数中分配的其他资源，这两种情况下都必须定义拷贝构造函数。

什么情况使用拷贝构造函数：

类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：

（1）一个对象以值传递的方式传入函数体
（2）一个对象以值传递的方式从函数返回
（3）一个对象需要通过另外一个对象进行初始化。

关于为什么当类成员中含有指针类型成员且需要对其分配内存时，一定要有总定义拷贝构造函数？？

默认的拷贝构造函数实现的只能是浅拷贝，即直接将原对象的数据成员值依次复制给新对象中对应的数据成员，并没有为新对象另外分配内存资源。

这样，如果对象的数据成员是指针，两个指针对象实际上指向的是同一块内存空间。

在某些情况下，浅拷贝回带来数据安全方面的隐患。

当类的数据成员中有指针类型时，我们就必须定义一个特定的拷贝构造函数，该拷贝构造函数不仅可以实现原对象和新对象之间数据成员的拷贝，而且可以为新的对象分配单独的内存资源，这就是深拷贝构造函数。

如何防止默认拷贝发生

声明一个私有的拷贝构造函数，这样因为拷贝构造函数是私有的，如果用户试图按值传递或函数返回该类的对象，编译器会报告错误，从而可以避免按值传递或返回对象。

总结：

当出现类的等号赋值时，会调用拷贝函数，在未定义显示拷贝构造函数的情况下，系统会调用默认的拷贝函数——即浅拷贝，它能够完成成员的一一复制。当数据成员中没有指针时，浅拷贝是可行的。但当数据成员中有指针时，如果采用简单的浅拷贝，则两类中的两个指针将指向同一个地址，当对象快结束时，会调用两次析构函数，而导致指针悬挂现象。所以，这时，必须采用深拷贝。

深拷贝与浅拷贝的区别就在于深拷贝会在堆内存中另外申请空间来储存数据，从而也就解决了指针悬挂的问题。简而言之，当数据成员中有指针时，必须要用深拷贝。