关于c++深拷贝与浅拷贝

首先看一段代码：

 #include<iostream>
 #include<cstring>
 #include<malloc.h>
 using namespace std;

 class Teacher{
 public:
     Teacher(int id,char *name){
         m_id=id;

         m_name=(char*)malloc(strlen(name)+);//由于显示析构函数中free内存空间，因而必须malloc
         strcpy(m_name,name);
     }

     void Print(){
         cout<<"id="<<m_id<<" name="<<m_name<<endl;
     }

     ~Teacher(){/*显示析构函数*/
         cout<<"Teacher()..."<<endl;
         if(m_name!=NULL){
             free(m_name);
             m_name=NULL;
         }
     }
 private:
     int m_id;
     char *m_name;
 };

 int main(){
     Teacher t1(,"zhangsan");
     t1.Print();

     return ;
 }

浅谈析构函数特点：

1.函数名是在类名前加上~，无参数且无返回值。

2.一个类只能有且有一个析构函数，如果没有显式的定义，系统会生成一个缺省的析构函数（合成析构函数）。

3.析构函数不能重载。每有一次构造函数的调用就会有一次析构函数的调用。

 #include<iostream>
 #include<cstring>
 #include<malloc.h>
 using namespace std;

 class Teacher{
 public:
     Teacher(int id,char *name){
         cout<<"Teacher(int,char*)..."<<endl;
         m_id=id;

         int len=strlen(name);
         m_name=(char*)malloc(len+);//由于显示析构函数中free内存空间，因而必须malloc
         strcpy(m_name,name);
     }
     /*默认拷贝构造函数，浅拷贝！！！*/
     Teacher(const Teacher& another){
         m_id=another.m_id;
         m_name=another.m_name;
     }
     void Print(){
         cout<<"id="<<m_id<<" name="<<m_name<<endl;
     }

     ~Teacher(){/*显示析构函数*/
         cout<<"Teacher()..."<<endl;
         if(m_name!=NULL){
             free(m_name);
             m_name=NULL;
         }
     }
 private:
     int m_id;
     char *m_name;
 };

 void test(){
     Teacher t1(,"xiaoming");
     t1.Print();

     Teacher t2(t1);//t2的默认拷贝构造
     t2.Print();
 }

 int main(){
     test();

     return ;
 }

【浅拷贝】是增加了一个指针，指向原来已经存在的内存。

而【深拷贝】是增加了一个指针，并新开辟了一块空间，让指针指向这块新开辟的空间

在test函数结束时，t1和t2都会走一遍析构函数，释放内存空间，t2后执行，因而先走析构函数，将name的内存空间释放掉，当t1走析构函数时，会再次进行m_name的内存空间释放，但由于这块内存空间在t2走析构函数时已经被释放掉了，所以在这里会引发段错误！！！，这也就是浅拷贝的危害。。。

为了避免浅拷贝引发的段错误，因而我们需要进行深拷贝，重写拷贝构造函数

 #include<iostream>
 #include<cstring>
 #include<malloc.h>
 using namespace std;

 class Teacher{
 public:
     Teacher(int id,char *name){
         cout<<"Teacher(int,char*)..."<<endl;
         m_id=id;

         int len=strlen(name);
         m_name=(char*)malloc(len+);//由于显示析构函数中free内存空间，因而必须malloc
         strcpy(m_name,name);
     }
     /*重写拷贝构造函数，深拷贝*/
     Teacher(const Teacher& another){
         m_id=another.m_id;
         //深拷贝//
         int len=strlen(another.m_name);
         m_name=(char*)malloc(len+);
         strcpy(m_name,another.m_name);
     }
     void Print(){
         cout<<"id="<<m_id<<" name="<<m_name<<endl;
     }

     ~Teacher(){/*显示析构函数*/
         cout<<"Teacher()..."<<endl;
         if(m_name!=NULL){
             free(m_name);
             m_name=NULL;
         }
     }
 private:
     int m_id;
     char *m_name;
 };

 void test(){
     Teacher t1(,"xiaoming");
     t1.Print();

     Teacher t2(t1);//t2的默认拷贝构造
     t2.Print();
 }

 int main(){
     test();

     return ;
 }