C++ 深拷贝与浅拷贝

深拷贝与浅拷贝

简单的来说，浅拷贝是增加了一个指针，指向原来已经存在的内存。而深拷贝是增加了一个指针，并新开辟了一块空间让指针指向这块新开辟的空间。

浅拷贝在多个对象指向一块空间的时候，释放一个空间会导致其他对象所使用的空间也被释放了，再次释放便会出现错误。

浅拷贝

为了形象化说明什么是深拷贝和浅拷贝，我们就先写一个String类(包含构造函数、拷贝构造函数、赋值运算符重载、析构函数和输出操作符"<<"的重载)。

class String  
{  
public:  
    String(const char *p = "")  //构造函数
    {  
        if(p == NULL)  
        {  
            p = new char[1];  
            *p = '\0';  
        }  
        else  
        {  
            pstr = new char[strlen(pStr)+1]; //加1，存放'\0'  
            strcpy(pstr, p); //用拷贝字符串的函数
        }  
    }  
      
    String(const String &s) : pstr(s.pstr)//拷贝构造函数，浅拷贝指向同一块空间，可能造成释放的错误，这是浅拷贝的缺点
    {}  
      
    String& operator=(const String &s)  //=运算符重载
    {  
        if(this != &s)  
        {  
            delete[] pstr; //将原来所指向的空间释放
            pstr = s.pstr; //让pstr重新指向s的pstr所指向的空间（也会导致错误）  
        }
        return *this;  
    }  



    ~String() //析构函数
    {  
        if(NULL != pstr)  
        {  
            delete[] pstr; //释放指针所指向的内容
            pstr = NULL; //将指针置为空
        }
    }

    friend ostream&operator<<(ostream & _cout,const String &s)  //<<运算符重载
    {  
        _cout<<s.pstr;  
        return _cout;  
    }  


private:  
    char *pstr;
};  

经过测试之后，在某种情况下是可以正常运行的，在特定情况下是不可以正常的运行的。

int main()  
{     
    String s1("sss");  
    String s2(s1);  
    String s3(NULL);  
    s3 = s1;  
    cout<<s1<<endl;  
    cout<<s2<<endl;  
    cout<<s3<<endl;  
    return 0;  
}  

在该例子中，我们有三个String类的对象，s1调用【构造函数】存入字符"sss"，s2调用【拷贝构造函数】来利用s1进行初始化，s3则用【赋值运算符】来进行初始化。
接下来看一下析构函数：

~String()  
{  
    if (pstr != NULL)  
    {  
        delete[] pstr;  
        pstr = NULL;  
    }  
}  

由于s1、s2、s3都指向同一块空间。
当我们释放s3的时候，可以正常释放，然而当释放s2的时候，由于s3已经释放过了，所以s2所指向的这段空间已经不属于s1或者s2了。
此时我们调用delete释放的时候，必然会崩溃。

深拷贝

深拷贝和浅拷贝的不同之处，仅仅在于修改了拷贝构造函数，以及赋值运算符的重载。

String(const String &s) : pstr(new char[strlen(s.pstr)+1])  
{  
    strcpy(pstr, s.pstr);   
}  
  
/* 浅拷贝
String(const String &s) : pstr(s.pstr)//拷贝构造函数，浅拷贝指向同一块空间，可能造成释放的错误，这是浅拷贝的缺点
{}      
*/

String& operator=(const String &s)  
{  
    if(this != &s)  
    {  
        char* tmp = new char[strlen(s.pstr)+1]; //动态开辟一个临时变量，然后将pstr指向这一个新的临时变量里  
        delete[] pstr; //将原来的空间进行释放  
        strcpy(tmp,s.pstr); //将s.pstr里的内容复制到临时变量中  
        pstr = tmp; //pstr指向临时变量的这段空间  
    }  
    return *this;  
}  

/* 浅拷贝
String& operator=(const String&s)  
{  
    if(this != &s)  
    {  
        delete[] pstr;//将原来所指向的空间释放   
        pstr = s.pstr;//让pstr重新指向s的pstr所指向的空间（也会导致错误）   
    }   
    return *this;  
} 
*/

深拷贝增加了一个指针指向新开辟了一块空间，使用的时候需要注意内存泄漏问题。