构造函数可以重载，析构函数不可以重载。

因为构造函数可以有多个且可以带参数，析构函数只有一个且不能带参数。

转自：/feitianxuxue/article/details/9275979#comments

对深拷贝与浅拷贝的再次理解

记得底找工作的时候，面试时曾经遇到有面试官问的对深拷贝与浅拷贝的理解，那时候自己回来查了资料，写了篇博客，感觉自己理解了，其实理解的不深刻，最近在调试bug的时候，再次遇到深拷贝与浅拷贝，认真分析了，写写自己的心得吧。

先说下自己的理解吧，浅拷贝，即在定义一个类A，使用类似Aobj;Aobj1(obj);或者Aobj1=obj;时候，由于没有自定义拷贝构造函数，C++编译器自动会产生一个默认的拷贝构造函数。这个默认的拷贝构造函数采用的是“位拷贝”（浅拷贝），而非“值拷贝”（深拷贝）的方式，如果类中含有指针变量，默认的拷贝构造函数必定出错。

用一句简单的话来说就是浅拷贝，只是对指针的拷贝，拷贝后两个指针指向同一个内存空间，深拷贝不但对指针进行拷贝，而且对指针指向的内容进行拷贝，经深拷贝后的指针是指向两个不同地址的指针。

浅拷贝会出现什么问题呢？

假如有一个成员变量的指针，char*m_data;

其一，浅拷贝只是拷贝了指针，使得两个指针指向同一个地址，这样在对象块结束，调用函数析构的时，会造成同一份资源析构2次，即delete同一块内存2次，造成程序崩溃。

其二，浅拷贝使得obj.m_data和obj1.m_data指向同一块内存，任何一方的变动都会影响到另一方。

其三，在释放内存的时候，会造成obj1.m_data原有的内存没有被释放（这句话，刚开始我不太理解，如果没有走自定义的拷贝构造函数，申请内存空间，Aobj1(obj);也不走默认构造函数，走的是默认的拷贝构造函数，何来分配空间一说，更不会造成obj1.m_data原有的内存没有被释放，这里刚开始我一直有疑问），造成内存泄露。

事实是这样的，当deleteobj.m_data,obj.m_data内存被释放后，由于之前obj.m_data和obj1.m_data指向的是同一个内存空间，obj1.m_data所指的空间不能在被利用了，deleteobj1.m_data也不会成功，一致已经无法操作该空间，所以导致内存泄露。

深拷贝采用了在堆内存中申请新的空间来存储数据，这样每个可以避免指针悬挂。

下面来看看类string的拷贝构造函数

[cpp]view plaincopyclassString { public: String(constString&other);//拷贝构造函数 private: char*m_data;//用于保存字符串 }; String(constString&other) { intlength=strlen(other.m_data); m_data=newchar[length+1]; strcpy(m_data,other.m_data); }

可以看到在拷贝构造函数中为成员变量申请了新的内存空间，这就使得两个对象的成员变量不指向同一个内存空间，除非你的确需要这样做，用于实现一些其他的用途。

浅拷贝：也就是在对象复制时，只是对对象中的数据成员进行简单的赋值，如果对象中存在动态成员，即指针，浅拷贝就会出现问题，下面代码：

[cpp]view plaincopy#include<stdio.h> classA { public: A()//构造函数，p指向堆中分配的一空间 { m_data=newchar(100); printf("默认构造函数\n"); } ~A()//析构函数，释放动态分配的空间 { if(m_data!=NULL) { deletem_data; m_data=NULL; printf("析构函数\n"); } } private: char*m_data;//一指针成员 }; intmain() { Aa; Ab(a);//复制对象 return0; }

运行结果：

***glibcdetected***./simple:doublefreeorcorruption(fasttop):0x000000000c62a010***

分析：由于没有拷贝构造函数，走编译器默认的拷贝构造函数，Ab(a);进行对象析构时，会造成释放同一内存空间2次，导致内存泄露。

深拷贝：对于深拷贝，针对成员变量存在指针的情况，不仅仅是简单的指针赋值，而是重新分配内存空间，如下：

[cpp]view plaincopy#include<stdio.h> #include<string> classA { public: A()//构造函数，p指向堆中分配的一空间 { m_pdata=newchar(100); printf("默认构造函数\n"); } A(constA&r) { m_pdata=newchar(100);//为新对象重新动态分配空间 memcpy(m_pdata,r.m_pdata,strlen(r.m_pdata)); printf("copy构造函数\n"); } ~A()//析构函数，释放动态分配的空间 { if(m_pdata!=NULL) { deletem_pdata; printf("析构函数\n"); } } private: char*m_pdata;//一指针成员 }; intmain() { Aa; Ab(a);//复制对象 return0; }

下面是我在具体的应用中使用深拷贝的情况，现在把这个demo贴出来：

[cpp]view plaincopy#include<iostream> #include<errno.h> #include<vector> #include<stdio.h> usingnamespacestd; /*存储记录信息的结构体*/ typedefstruct_RECODER_VALUE_STRU { intId; intAge; }RECODER_VALUE_STRU; classrecorder { public: recorder() { m_stru_RecValue.Id=-1; m_stru_RecValue.Age=-1; m_pRecValue=&m_stru_RecValue; m_paddr=newchar[100]; memset(m_paddr,0x00,100); printf("默认constructrecorder->&m_stru_RecValue:%x,\tm_pRecValue:%x\tm_paddr:%x\n",&m_stru_RecValue,m_pRecVa lue,m_paddr); } //拷贝构造函数 /*recorder(constrecorder&recorder) {m_stru_RecValue.Id=-1; m_stru_RecValue.Age=-1; m_stru_RecValue=recorder.m_stru_RecValue; m_pRecValue=&m_stru_RecValue; m_paddr=newchar[100]; memset(m_paddr,0x00,100); memcpy(m_paddr,recorder.m_paddr,strlen(recorder.m_paddr)); printf("拷贝constructrecorder->&m_stru_RecValue:%x\tm_pRecValue:%x\tm_paddr:%x\n",&m_stru_RecValue,m_pRecValu e,m_paddr); } */ //构造函数 recorder(intiId,intiAge) { m_stru_RecValue.Id=iId; m_stru_RecValue.Age=iAge; m_pRecValue=&m_stru_RecValue; m_paddr=newchar[100]; memset(m_paddr,0x00,100); memcpy(m_paddr,&iAge,sizeof(int)); printf("constructrecorder->&m_stru_RecValue:%x\tm_pRecValue:%x\tm_paddr:%x\n",&m_stru_RecValue,m_pRecValue, m_paddr); } ~recorder() { //cout<<"recorder析构"<<endl; /*if(m_paddr!=NULL) {deletem_paddr; m_paddr=NULL; }*/ } public: RECODER_VALUE_STRUm_stru_RecValue;//存储记录信息的结构体 void*m_pRecValue;//每条记录的值 char*m_paddr; }; intmain() { cout<<"测试默认构造函数"<<endl<<endl; recorderbtest; recorderbtest1(btest); printf("非参：btest->&m_stru_RecValue:%x\taddr:%x\tm_paddr:%x\n",&btest.m_stru_RecValue,btest.m_pRecValue,btest.m_paddr); printf("非参：btest1->&m_stru_RecValue:%x\taddr:%x\tm_paddr:%x\n",&btest1.m_stru_RecValue,btest1.m_pRecValue,btest1.m_paddr); cout<<endl<<"测试带参数的构造函数"<<endl<<endl; recorderbtest2(1,100); recorderbtest3(btest2); printf("带参：btest2->m_stru_RecValue:%x\tm_pRecValue:%x\t,m_paddr:%x\n",&btest2.m_stru_RecValue,btest2.m_pRecValue,btest2.m_ paddr); printf("带参：btest3->m_stru_RecValue:%x\tm_pRecValue:%x\t,m_paddr:%x\n",&btest3.m_stru_RecValue,btest3.m_pRecValue,btest3.m_ paddr); return0; }

对比结果：

注释掉自定义拷贝构造函数,运行结果：

测试默认构造函数

默认constructrecorder->&m_stru_RecValue:ddbb8de0,m_pRecValue:ddbb8de0m_paddr:1b8a0010

非参：btest->&m_stru_RecValue:ddbb8de0addr:ddbb8de0m_paddr:1b8a0010

非参：btest1->&m_stru_RecValue:ddbb8dc0addr:ddbb8de0m_paddr:1b8a0010

测试带参数的构造函数

constructrecorder->&m_stru_RecValue:ddbb8da0m_pRecValue:ddbb8da0m_paddr:1b8a0080

带参：btest2->m_stru_RecValue:ddbb8da0m_pRecValue:ddbb8da0,m_paddr:1b8a0080

带参：btest3->m_stru_RecValue:ddbb8d80m_pRecValue:ddbb8da0,m_paddr:1b8a0080

默认拷贝构造函数结果分析：

通过结果可以看出，当成员变量为指针变量的时候，指针成员变量指向的地址都是同一个地址，无论是申请空间的成员变量m_pRecValue，和仅仅作为指针赋值的成员变量m_paddr；结构体的地址是变化的，除了指针浅拷贝与深拷贝没什么区别。

打开自定义拷贝构造函数，运行结果：

测试默认构造函数

默认constructrecorder->&m_stru_RecValue:58bb9e20,m_pRecValue:58bb9e20m_paddr:7a2c010

拷贝constructrecorder->&m_stru_RecValue:58bb9e00m_pRecValue:58bb9e00m_paddr:7a2c080

非参：btest->&m_stru_RecValue:58bb9e20addr:58bb9e20m_paddr:7a2c010

非参：btest1->&m_stru_RecValue:58bb9e00addr:58bb9e00m_paddr:7a2c080

测试带参数的构造函数

constructrecorder->&m_stru_RecValue:58bb9de0m_pRecValue:58bb9de0m_paddr:7a2c0f0

拷贝constructrecorder->&m_stru_RecValue:58bb9dc0m_pRecValue:58bb9dc0m_paddr:7a2c160

带参：btest2->m_stru_RecValue:58bb9de0m_pRecValue:58bb9de0,m_paddr:7a2c0f0

带参：btest3->m_stru_RecValue:58bb9dc0m_pRecValue:58bb9dc0,m_paddr:7a2c160

自定义深拷贝构造函数结果分析：

从结果可以看出，所有成员变量的地址都不相同。

其他：

1.有时候为了防止默认拷贝发生，可以声明一个私有的拷贝构造函数（不用写代码），这样的话，如果试图调用Ab(a);就调用了私有的拷贝构造函数，编译器会报错，这也是一种偷懒的做法。

2.一个类中可以存在多个拷贝构造函数，例如：

[cpp]view plaincopyCalssA { Public: X(constX&);//const拷贝构造 X(X&);//非const拷贝构造 X(X&,intiData); }