注：博客中内容主要来自《狄泰软件学院》，博客仅当私人笔记使用。

测试环境：Ubuntu 10.10

GCC版本：4.4.5

一、特殊的构造函数

1）两个特殊的构造函数

     - 无参构造函数

       *没有参数的构造函数

       *当类中没有定义构造函数时，编译器默认提供一个无参数构造函数，并且其函数体为空。

     - 拷贝构造函数

       *参数为const class_name&的构造函数   const+class_name&（引用类名）

       *当类中没有定义拷贝构造函数时，编译器默认提供一个拷贝构造函数，简单的进行成员变量的值复制。

        这里的const + class_name&会有临时对象产生，也就是会有构造函数被调用。

编程实验
特殊的构造函数
19-1.cpp
#include <stdio.h>class Test
{
private:int i;int j;
public:int getI(){return i;}int getJ(){return j;}/*Test(const Test& t)    //拷贝构造函数{i = t.i;j = t.j;}Test(){}*/
};int main()
{Test t1;   //创建一个类对象时，必须创建构造函数，我们没创建构造函数，但是编译通过.因此编译器为我们提供了一个默认的构造函数Test t2 = t1;printf("t1.i = %d, t1.j = %d\n", t1.getI(), t1.getJ());  //打印随机值printf("t2.i = %d, t2.j = %d\n", t2.getI(), t2.getJ());  //打印随机值return 0;
}

操作：

1) g++ 19-1.cpp -o 19-1.out编译正确，打印结果：

t1.i = -1217166396, t1.j = -1216897024
t2.i = -1217166396, t2.j = -1216897024    

2) 只给类Test添加拷贝构造函数，代码如下：

#include <stdio.h>class Test
{
private:int i;int j;
public:int getI(){return i;}int getJ(){return j;}Test(const Test& t)    //拷贝构造函数{i = t.i;j = t.j;}
};int main()
{Test t1;   //创建一个类对象时，必须创建构造函数，我们没创建构造函数，但是编译通过.因此编译器为我们提供了一个默认的构造函数Test t2 = t1;    //调用Test(const Test& t)printf("t1.i = %d, t1.j = %d\n", t1.getI(), t1.getJ());  //打印随机值printf("t2.i = %d, t2.j = %d\n", t2.getI(), t2.getJ());  //打印随机值return 0;
}

编译报错：

19-1.cpp:28:7: error: no matching function for call to 'Test::Test()'Test t1;
错误：没有匹配函数Test::Test()

分析：

        Test t1;类实例化时没有无参拷贝构造函数。

修改代码，添加无参构造函数：

#include <stdio.h>class Test
{
private:int i;int j;
public:int getI(){return i;}int getJ(){return j;}Test(const Test& t)    //拷贝构造函数{i = t.i;j = t.j;}Test(){}
};

编译正常。

面试题：

下面的的类里有什么？

class T
{
};

至少有一个无参构造函数。

二、拷贝构造函数

1）拷贝构造函数的意义

     - 兼容C语言的初始化方式

     - 初始化行为能够符合预期的逻辑

     - 浅拷贝（编译器提供，也可以自己写）

       *拷贝后对象的物理状态相同  单纯进行值拷贝

     - 深拷贝（自己编写）

       *拷贝后对象的逻辑状态相同  什么是逻辑：功能相同，实现功能的对象不同

       编译器提供的拷贝构造函数只进行浅拷贝！

编程实验
对象的初始化
19-2.cpp#include <stdio.h>class Test
{
private:int i;int j;int* p;
public:int getI(){return i;}int getJ(){return j;}int* getP(){return p;}/*    //测试深拷贝时打开Test(const Test& t)   //这里深拷贝{i = t.i;j = t.j;p = new int;   //新申请内存*p = *t.p;}*/Test(int v)  //初始化参数{i = 1;j = 2;p = new int;*p = v;}void free(){delete p;}
};int main()
{Test t1(3);Test t2(t1);    //如果不自己编写拷贝构造函数，这会导致释放内存相同//浅拷贝，p指向同一个地址，free时二次释放   printf("t1.i = %d, t1.j = %d, *t1.p = %d\n", t1.getI(), t1.getJ(), *t1.getP());printf("t2.i = %d, t2.j = %d, *t2.p = %d\n", t2.getI(), t2.getJ(), *t2.getP());/*  //测试深拷贝printf("t1.i = %d, t1.j = %d, t1.p = %p\n", t1.getI(), t1.getJ(), t1.getP());  //和下一行地址不同printf("t2.i = %d, t2.j = %d, t2.p = %p\n", t2.getI(), t2.getJ(), t2.getP());  // */t1.free();t2.free();return 0;
}

操作：

1) g++ 19-2.cpp -o 19-2.out编译正常，运行错误：

t1.i = 1, t1.j = 2, *t1.p = 3
t2.i = 1, t2.j = 2, *t2.p = 3
*** Error in './19-2.out': double free or corruption(fasttop): 0x09e1e008 *
Aborted (core dumped)
错误在'19-2.out': 两次释放内存0x09e1e008  

分析：

        因为是浅拷贝，t1.free()和t2.free()两次释放相同内存。

解决办法：

        给Test类添加拷贝构造函数，代码如下：

19-2.cpp#include <stdio.h>class Test
{
private:int i;int j;int* p;
public:int getI(){return i;}int getJ(){return j;}int* getP(){return p;}//测试深拷贝时打开Test(const Test& t)   //这里深拷贝{i = t.i;j = t.j;p = new int;   //新申请内存*p = *t.p;}Test(int v)  //初始化参数{i = 1;j = 2;p = new int;*p = v;}void free(){delete p;}
};int main()
{Test t1(3);Test t2(t1);    //如果不自己编写拷贝构造函数，这会导致释放内存相同printf("t1.i = %d, t1.j = %d, *t1.p = %d\n", t1.getI(), t1.getJ(), *t1.getP());printf("t2.i = %d, t2.j = %d, *t2.p = %d\n", t2.getI(), t2.getJ(), *t2.getP());//测试深拷贝printf("t1.i = %d, t1.j = %d, t1.p = %p\n", t1.getI(), t1.getJ(), t1.getP());  printf("t2.i = %d, t2.j = %d, t2.p = %p\n", t2.getI(), t2.getJ(), t2.getP()); t1.free();t2.free();return 0;
}

g++ 19-2.cpp -o 19-2.out编译正常，打印如下：

t1.i = 1, t1.j = 2, *t1.p = 3
t2.i = 1, t2.j = 2, *t2.p = 3    
t1.i = 1, t1.j = 2, t1.p = 0x9a28008    
t2.i = 1, t2.j = 2, t2.p = 0x9a28018    

2）什么时候需要进行深拷贝？

 - 对象中有成员指代了系统中的资源

   *    成员指向动态内存空间

   *    成员打开了外存中文件

   *    成员使用了系统中网络端口

   *    ……

3）问题分析   浅拷贝时

这就是为什么释放相同内存导致崩溃！ 

4）一般性原则

自定义拷贝构造函数，必然需要实现深拷贝！！

           一定要好好分析之前的例子！

编程实验
数组类的改进
IntArray.cpp#include "IntArray.h"IntArray::IntArray(int len)
{m_pointer = new int[len];for(int i=0; i<len; i++){m_pointer[i] = 0;}m_length = len;
}IntArray::IntArray(const IntArray& obj)    //深拷贝，有内存申请
{m_length = obj.m_length;m_pointer = new int[obj.m_length];for(int i=0; i<obj.m_length; i++){m_pointer[i] = obj.m_pointer[i];}
}int IntArray::length()
{return m_length;
}bool IntArray::get(int index, int& value)
{bool ret = (0 <= index) && (index < length());if( ret ){value = m_pointer[index];}return ret;
}bool IntArray::set(int index, int value)
{bool ret = (0 <= index) && (index < length());if( ret ){m_pointer[index] = value;}return ret;
}void IntArray::free()
{delete[]m_pointer;
}IntArray.h#ifndef _INTARRAY_H_
#define _INTARRAY_H_class IntArray
{
private:int m_length;int* m_pointer;
public:IntArray(int len);IntArray(const IntArray& obj);int length();bool get(int index, int& value);bool set(int index ,int value);void free();
};#endifmain.c
#include <stdio.h>
#include "IntArray.h"int main()
{IntArray a(5);    for(int i=0; i<a.length(); i++){a.set(i, i + 1);}for(int i=0; i<a.length(); i++){int value = 0;if( a.get(i, value) ){printf("a[%d] = %d\n", i, value);}}IntArray b = a;  //a对象初始化b对象for(int i=0; i<b.length(); i++){int value = 0;if( b.get(i, value) ){printf("b[%d] = %d\n", i, value);}}a.free();b.free();return 0;
}

操作：

1) g++ main.cpp IntArray.cpp -o IntArray.out编译正常，打印结果：

a[0] = 1
a[1] = 2
a[2] = 3
a[3] = 4
a[4] = 5
b[0] = 1
b[1] = 2
b[2] = 3
b[3] = 4
b[4] = 5

小结

1）C++编译器会默认提供构造函数

2）无参构造函数用于定义对象的默认初始状态(无参构造函数和拷贝构造函数使用方式)

3）拷贝构造函数在创建对象时拷贝对象的状态(有拷贝构造函数必须有无参构造函数)

4）对象的拷贝有浅拷贝和深拷贝两种方式

        -    浅拷贝使得对象的物理状态相同（编译器完成，也可以自己写）

        -    深拷贝使得对象的逻辑状态相同（自己手写）