深浅拷贝与写时拷贝

在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;}