深浅拷贝与写时拷贝

在c++中，基本所有的类都要考虑深拷贝，浅拷贝与写时拷贝，根据不同的定义，选择适合自己的拷贝方式。时间类就可以用浅拷贝，而二叉树，string类就需要深拷贝。
string类在vs编译器下使用的深拷贝，在Linux下使用的浅拷贝。
为什么会存在深浅拷贝的问题呢？
string的浅拷贝是让两个不同的指针指向同一块空间，而这在析构的时候会出现将一块空间释放两次，程序会崩溃，因此我们才需要进行深拷贝，即第二个指针开辟和第一个指针一样大小空间，然后将内容复制过去。
深拷贝:

ass string
{
public:
    string(char* pstr)    //构造函数
        :str(new char[strlen(pstr) + 1])   //开辟新的空间
    {
        if (pstr == NULL)//
        {
            str = new char[1];    //开辟一个 存放‘\0’
            *str = '\0';
        }
        else
        {
            str = new char[strlen(pstr) + 1];
            for (size_t i = 0; i < strlen(pstr); i++)  //深复制
            {
                str[i] = pstr[i];
            }
            //strcpy(str,pstr);
            //memcpy(str,pstr,strlen(pstr)+1);浅复制
        }
    }
    //拷贝构造函数
    string(const string& pstr)
        :str(new char[strlen(pstr.str)+1])
    {
        for (size_t i = 0; i < strlen(pstr.str); i++)
        {
            str[i] = pstr.str[i];
        }
        //strcpy(str,pstr.str);
        //memcpy(str,pstr.str,strlen(pstr.str)+1);
    }
    //赋值运算符重载
    string& operator = (const string & pstr)
    {
        if (&str == &pstr.str)     //检查是否是自己给自己赋值
            return *this;
        delete[] str;             //释放临时空间
        str = new char[strlen(pstr.str) + 1];
        for (size_t i = 0; i < strlen(pstr.str); i++)
        {
            str[i] = pstr.str[i];
        }
        //strcpy(str,pstr.str);
        //memcpy(str,pstr.str,strlen(pstr.str)+1);
        return *this;
    }
    /*现代写法： 根据拷贝构造函数让系统自己开辟空间 
    拷贝构造函数
    string（const string& pstr）
         :str=null;    必须置为空，要不然访问地址非法化
         {    
             string tmp (pstr);
             swap(tmp.str,str);
             return *this;
         }
    赋值运算符重载
    string& operator = (const string& pstr )
    {
        string tmp(pstr);
        swap(tmp.str, str);
        return *this;
     }*/
    //析构函数
    ~string()
    {
        delete[] str;
        str = NULL;
    }

private:
    char* str;

};
int main()
{
    string a ("12345");
    string b(a);
    cout << b << endl;
}

浅拷贝，当我们需要改变新的空间的内容的时候，才会重新开辟空间呢？
1）判断空间使用的次数来选择析构，增加一个类成员 count，但是这样造成的后果是每一个成员都有一个不同的count 在析构的时候就很混乱还是会出错
2）然后呢我们会想到使用静态成员的办法，因为此时 static int count 是放在静态区，它是所有对象共享的，不会为每个对象单独生成一个count，可是当我们有多个不同的成员共同管理一块空间，而此时我们又用构造函数创建一个对象时候，count又会变为1，所以这种方法还是不行 。
3）使用引用计数，把引用计数放在字符串的前四个字节里，每个创建出来的对象都有不同的引用计数

class string
{
public:
    string(char* pstr)    //构造函数
        :str(new char[strlen(pstr) + 1+4])//多开辟的4个字节存放引用计数
    {
        if (pstr == NULL)
        {
            str = new char[1];
            *str = '\0';
        }
        else
        {
            str = new char[strlen(pstr) + 1+4];
            int* count = (int* )str;
            *count = 1;
            count ++;  //后移拷贝数据
            str = (char*)count;
            for (size_t i = 0; i < strlen(pstr); i++)  //深复制
            {
                str[i] = pstr[i];
            }
            //strcpy(str,pstr);
            //memcpy(str,pstr,strlen(pstr)+1);浅复制
        }
    }
    //拷贝构造函数
    string(const string& pstr)
    {
        str = pstr.str;
        int * count = (int *)(str-4) ;
        ++*count;

    }
    //赋值运算符重载
    string& operator = (const string & pstr)
    {
        if (&str == &pstr.str)
            return *this;
        destroy();//判断是否释放空间
        str = pstr.str;
        int * count = (int *)(str-4) ;
        ++*count;
    }
void destroy()
{
    int * count = (int *)(str-4); //获取引用计数
    if（*count == 1）
    {
       delete[](str-4);
       str = NULL;
    }
    else
      --*count;
}
//析构函数
~string（）
{
   destroy（）;
}

private:
    char* str;
    int * count;
};

写时拷贝：
在浅拷贝中，假设有多个名称引用了同一个字符串，当其中一个需要修改字符串时，这就会导致引用的值发生改变，这明显不是我们所期望的，所以出现了写时拷贝，（可能会修改字符串的时候使用深拷贝将其与大部队分离，这样就保护了其他引用成员）
则我们只需要重载[] 就可以实现

const string& operator[]const 
{
        string tmp(pstr);
        swap(tmp.str, str);
        return *this;
}