C++构造函数、复制构造函数，拷贝构造函数(深拷贝、浅拷贝)-创新互联

• (1) 当用一个对象去初始化同类的另一个对象时，会引发复制构造函数被调用。
  例如，下面的两条语句都会引发复制构造函数的调用，用以初始化 test2

Demo test2 (test1);
Demo test2  = test1;

这两句是等价的，它们都是初始化test2
`提示：这里需要注意的是，初始化与赋值的区别：当等号左边变量有类型时，这是初始化，不是赋值。例如：

Demo test2  = test1;//这是初始化
Demo test2 test1；
test = test1; // 这是赋值

• (2) 如果一个函数的参数是另一个类的对象，那么当次函数被调用时，类的复制构造函数将被调用。
  换句话说，作为形参的对象，是用复制构造函数初始化的，而且调用复制构造函数时的参数，就是调用函数时所给的实参。

示例如下：

#includeusing namespace std;
class A{public:
    A(){};
    A(A & a){cout<<"Copy constructor called"<} //参数是A的对象，此时会调用A的复制构造函数
int main(){A a;
    Func(a);
    return 0;
}

• (3) 如果函数的返冋值是类 A 的对象，则函数返冋时，类 A 的复制构造函数被调用。换言之，作为函数返回值的对象是用复制构造函数初始化 的，而调用复制构造函数时的实参，就是 return 语句所返回的对象.

代码示例：

#includeusing namespace std;
class A {public:
    int v;
    A(int n) {v = n; };
    A(const A & a) {v = a.v;
        cout<< "Copy constructor called"<< endl;
    }
};
A Func() {A a(4);
    return a;
}
int main() {cout<< Func().v<< endl;
    return 0;
}

程序的输出结果是：

Copy constructor called
4

上述讲到了复制构造函数，又叫拷贝构造函数，同时也知道了拷贝构造函数触发的条件。
那么我们又要开始思考了，拷贝构造函数就只有一种吗？说起拷贝，让我们不由想到了C语言中的值传递、址传递。同样的，拷贝构造也分两类，分别叫：浅拷贝、深拷贝。

那么我们下面来讲讲，浅拷贝与深拷贝的区别。

• 拷贝构造也分两类，分别叫：浅拷贝、深拷贝。

浅拷贝：在未定义显示拷贝构造函数的情况下，系统会调用默认的拷贝函数
深拷贝：当拷贝一个对象时，如果需要拷贝这个对象引用的对象，则是深拷贝

浅拷贝和深拷贝主要区别：

复制指针时是否重新创建内存空间。如果没有没有创建内存只赋值地址为浅拷贝，  
创建新内存把值全部拷贝一份就是深拷贝。浅拷贝在类里面有指针成员的情况下只会复制指针的地址，会导致  
两个成员指针指向同一块内存，这样在要是分别delete释放时就会出现问题，因此需要用深拷贝。

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

浅拷贝：

class A 
{public: 
	A(int _data) : data(_data){} 
	A(){}
private: 
	int data;
 };
int main() 
{A a(10), b = a; // 仅仅是数据成员之间的赋值 
	std::cout<

运行结果：
first a.data = 10
then a.data = 20

对象之间的拷贝，其实就是对象成员之间的各个成员的赋值。
对象a,与对象b。 b=a即为把 a中的data数据，赋值给了b中的data

提示： 浅拷贝，时两个对象共同使用一块内存空间。如图C语言中的址传递，当一个对象改变了成员中的变量时，另一个对象中的相同成员变量也会相应改变。从上面的demo中可以看出，a中的data被b对象改变从而影响了原来a中data的值。因此只需要记住：浅拷贝会引起成员变量的改变

如果对象中没有其他的资源（如：堆，文件，系统资源等），则深拷贝和浅拷贝没有什么区别。
否则就需要使用深拷贝。

代码示例：

class A 
{public: 
	A(int _size) : size(_size)
	{data = new int[size];
	} // 假如其中有一段动态分配的内存 
	A(){};
	 ~A()
	{delete [] data;
	} // 析构时释放资源
private: 
	int* data;
	int size; 
}
int main() 
{A a(5), b = a; // 注意这一句 
}

这里b的指针data和a的指针指向了堆上的同一块内存，a和b析构时,b先把其data指向的动态分配的内存  
释放了一次,而后a析构时又将这块已经被释放过的内存再释放一次。对同一块动态内存执行2次以上释放  
的结果是未定义的，所以这将导致内存泄露或程序崩溃.所以这里就需要深拷贝来解决这个问题，深拷贝  
指的就是当拷贝对象中有对其他资源（如堆、文件、系统等）的引用 时 (引用可以是指针或引用)时,对  
象的另开辟一块新的资源，而不再对拷贝对象中有对其他资源的引用的指针或引  用进行单纯的赋值

深拷贝：
代码示例：

class A 
{public: 
	A(int _size) : size(_size)
	{data = new int[size];
	} // 假如其中有一段动态分配的内存 
	A(){};
	A(const A& _A) : size(_A.size)
	{data = new int[size];
	} // 深拷贝 
	~A()
	{delete [] data;
	} // 析构时释放资源
private: 
	int* data; 
 	int size;
 }
int main() 
{A a(5), b = a; // 这次就没问题了 
}