C++ 浅拷贝与深拷贝

（转发自：http://edu.codepub.com/2011/0123/29025.php）

对象的构造，也可以由拷贝构造函数完成，即用一个对象的内容去初始化另一个对象的内容。

此时，若对象使用了堆空间（注意和“堆对象”区分），就有深、浅拷贝的问题，不清楚则很容易出错。

1、什么是浅拷贝？

2、浅拷贝可能带来什么问题？

3、什么是深拷贝？

4、深拷贝的实现方法？

什么是浅拷贝

缺省拷贝构造函数：用一个对象的内容初始化另一个同类对象，也称为缺省的按成员拷贝，不是对整个类对象的按位拷贝。这种拷贝称为浅拷贝。

class CGoods{

           char *Name; //不同与char Name[21] ?

           int  Amount;

           float Price; float Total_value;

public： CGoods(){Name=new char[21];}

 CGoods(CGoods & other){ //缺省拷贝构造内容：

            this->Name=other.Name;

            this->Amount=other.Amount;

            this->Price=other.Price;

           this->Total_value="/blog/other.Total_value;}

~CGoods(){delete Name;}//析构函数
};  //类声明结束

浅拷贝带来的问题

void main(){

     CGoods pc;  //调用缺省构造函数

   CGoods pc1(pc);   //调用拷贝构造函数

} //程序执行完，对象pc1和pc将被析构，此时出错。

析构时，如用缺省的析构函数，则动态分配的堆空  

        间不能回收。

如果用有“delete Name;”语句的析构函数，则先

        析构pc1时，堆空间已经释放，然后再析构pc  

       时出现了二次释放的问题。

这时就要重新定义拷贝构造函数，给每个对象独

        立分配一个堆字符串，称深拷贝。

深拷贝——自定义拷贝构造

CGoods(CGoods & other){ //自定义拷贝构造

            this->Name=new char[21];

            strcpy(this->Name,other.Name);

            this->Amount=other.Amount;

            this->Price=other.Price;

            this->Total_value="/blog/other.Total_value;}

例子：定义copy structor和拷贝赋值操作符(copy Assignment Operator）实现深拷贝。
//学生类定义：

class student{

     char *pName; //指针成员

public:

     student();

     student(char *pname);

     student(student &s); //拷贝构造函数

     ~student();

     student & operator=(student &s);

                                    //拷贝赋值操作符

};

//缺省构造函数：

student::student()

 {   pName=NULL; cout<<“Constructor缺省 ";  }

//带参数构造函数：

student::student(char *pname){

       if(pName=new char[strlen(pname)+1])     

              strcpy(pName,pname);

       cout <<"Constructor" <<pName<<endl;}

//拷贝构造函数：

student::student(student &s){

    if(s.pName!=NULL){

        if(pName=new char[strlen(s.pName)+1])

               strcpy(pName,s.pName); }

  //加1不可少，否则串结束符冲了其他信息，析构会出错！

    else pName=NULL;

    cout <<"Copy Constructor" <<pName<<endl;}

//析构函数：

student::~student(){

    cout<<"Destructor"<<pName<<endl;

    if(pName) delete[ ]pName;} //释放字符串

//拷贝赋值操作符：

student & student::operator=(student &s){

    if(pName) delete[ ]pName;

    if(s.pName){

       if(pName=new char[strlen(s.pName)+1]) 

             strcpy(pName,s.pName);}

    else pName=NULL;

cout <<"Copy Assign operator" <<pName<<‘ ’;

    return *this;}

堆内存是最常用的需要自定义拷贝构造函数的资源，但不是唯一的，如打开文件等也需要。

   如果类需要析构函数来释放某些资源，则类也需要一个自定义的拷贝构造函数。此时，对象的拷贝就是深拷贝了。