C++之深浅拷贝

我们都知道，在C++中会用一个类变量构造同类变量时会用到拷贝构造函数。对于一般变量，我们在使用过程中并没有什么问题，定义也非常简单，一般我们所使用的都是浅拷贝，其实浅拷贝和深拷贝各有各的好处：
浅拷贝节省空间，但有时会出错，深拷贝更加安全，但有时候会造成不必要的空间浪费。

观察下面函数：

//如果Test类只有一个data值时：
Test(const Test &t)
{
    data = t.data;
}

显而易见，这个函数并没有什么错误，也能完成它的功能。但是，我们看下下面的例子，如果用浅拷贝整个程序运行通过不了了：

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

class String
{
public:
    String(const char *str = NULL)
    {
        cout << "String()!!" << endl;
        if(str == NULL){
            data = (char *)malloc(sizeof(char));
            data[0] = '\0';
        }else{
            data = (char *)malloc(strlen(str) + 1);
            strcpy(data, str);
        }
    }
    String(const String &str)
    {
        cout << "String(const String &str)!!" << endl;
        data = str.data;
    }
    char *GetData()
    {
        return this->data;
    }
    ~String()
    {
        cout << "~String()!!" << endl;
        free(data);
    }
private:
    char *data;
};

int main()
{
    String str("Hello");     //构造函数
    String str1;
    str1 = str;              //赋值运算
    String str2(str);        //拷贝构造

    cout << "str = " << str.GetData() << endl;
    cout << "str1 = " << str1.GetData() << endl;
    cout << "Str2 = " << str2.GetData() << endl;

    return 0;
}

运行发现程序core dumped。

很容易发现，程序调用了两次构造函数，一次拷贝构造函数，但析构了两个然后就core dumped了。这就是因为浅拷贝的问题：

在拷贝构造时，我们只是浅拷贝让str1的data指向了str的data空间，虽然是两个不同String变量，但内部data实际上指向的时同一空间，但是程序结束时，str和str1分别调用析构函数来释放它们内部的data值，这样该空间被释放了两次，所以程序运行到最后崩溃。

这里，我们解决的方法是，在String类中增加一个use_count计数值，让它记录指向data的变量个数。如果浅拷贝一次，use_count++,如果要改变某一个变量中的data值，先判断它的use_count值，如果只有它一个指向data时，直接更改，否则，要先对他进行深拷贝同时给use_count-1，然后在对它拷贝来的data值进行修改。析构同理，当use_count减为1时在析构，下面是代码实现：

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

class String;
ostream& operator<<(ostream &out, const String &s);

class String_rep
{  
    friend class String;
    friend ostream& operator<<(ostream &out, const String &s);
public:
    String_rep(const char *str = ""):use_count_(0)
    {
        data = new char[strlen(str) + 1];
        strcpy(data, str);
    }
    String_rep(const String_rep &s);
    String_rep& operator=(const String_rep &s)
    {
        //if(this != &s){
         //   data = s.rep->data;
            //increment();
        //}
        return *this;
    }
    ~String_rep()
    {
        delete data;
    }
public:
    void increment(){++use_count_;}
    void decrement()
    {
        //--use_count_;
        if(--use_count_ == 0){
            delete this;
        }
    }
    int use_count() const
    {
        return use_count_;
    }

private:
    char *data;
    int use_count_;
} ;

class String
{
    friend ostream& operator<<(ostream &out, const String &s);
public:
    String(const char *str = "") : rep(new String_rep(str))
    {
        rep->increment();
    }
    String(const String &s)
    {
        rep = s.rep;
        rep->increment();
    }
    String& operator=(const String &s)
    {
        if(this != &s){
            rep->decrement();
            rep = s.rep;
            rep->increment();
        }
        return *this;
    }
    ~String()
    {
        //int i = this->use_count;
        //if((--(rep->use_count_)) == 1){
            //free(rep->data);
            //delete rep;
        //}
        rep->decrement();
    }
public:
    int use_count() const
    {
        return rep->use_count();
    }
    void to_upper()
    {
        char *ch = rep->data;
        if(this->use_count() == 1){
            while(*ch != '\0'){
                *ch -= 32;
                ch ++;
            }
        }else{
            (rep->use_count_) --;
            rep = new String_rep(rep->data);
            strcpy(rep->data, ch);
            (rep->use_count_)++;
            ch = rep->data;
            while(*ch != '\0'){
                *ch -= 32;
                ch ++;
            }
        }
    }
private:
    String_rep *rep;
}s;

ostream& operator<<(ostream &out, const String &s)
{
    out << (s.rep)->data;
    return out;
}

int main()
{
    String s1("abcd");
    cout << "s1 = " << s1;
    cout << " s1 use_count = " << s1.use_count() << endl;
    String s2 = s1;
    cout << endl << "s2 = " << s2;
    cout << " s2 use_count = " << s2.use_count() << endl;

    String s3;
    s3 = s1;
    cout << endl << "s3 = " << s3;
    cout << " s3 use_count = " << s3.use_count() << endl;


    s2.to_upper();
    cout << endl << "s1 = " << s1;
    cout << " s1 use_count = " << s1.use_count() << endl;
    cout << "s2 = " << s2;
    cout << " s2 use_count = " << s2.use_count() << endl;
    cout << "s3 = " << s3;
    cout << " s3 use_count = " << s3.use_count() << endl;    
}

运行结果；

在拷贝构造时，深拷贝、浅拷贝各有千秋，我们只有恰当的使用它们，才能程序消耗空间尽可能小而且稳定。