深浅拷贝和写时拷贝

拷贝：  

     事实是，在对象拷贝过程中，如果没有自定义拷贝构造函数，系统会提供一个缺省的拷贝构造函数，缺省的拷贝构造函数对于基本类型的成员变量，按字节复制，对于类类型成员变量，调用其相应类型的拷贝构造函数。

浅拷贝：

      缺省拷贝构造函数在拷贝过程中是按字节复制的，对于指针型成员变量只复制指针本身，而不复制指针所指向的目标--浅拷贝。

浅拷贝的代码

class String
{
public:
       String(const char* str = "")
              :_str(new char[strlen(str) + 1])
       {
              strcpy(_str, str);
       }
       //拷贝构造函数，它是构造函数的重载
       String(const String& s)
       {
              //浅拷贝的情况下，只复制了指针本身，对指针所指向的内存并没有进行拷贝
              _str = s._str;
       }
       String& operator=(const String& s)
       {
              if (this != &s)
              {
                     _str = s._str;
              }
              return *this;
       }
       ~String()
       {
              if (_str)
              {
                     //指针指向相同的内存空间，再次释放一块已经释放的空间将会出现错误
                     delete[] _str;
              }
       }
private:
       char* _str;
};

浅拷贝出现的问题：

     （1）在进行对象复制后，事实上s1、s2里的成员指针m_psz都指向了一块内存空间（即内存空间共享了），在s1析构时，delete了成员指针m_psz所指向的内存空间，而s2析构时同样指向（此时已变成野指针）并且要释放这片已经被s1析构函数释放的内存空间，这就让同样一片内存空间出现了重复释放 ，从而出错。

     （2）而浅拷贝还存在着一个问题，因为一片空间被两个不同的子对象共享了，只要其中的一个子对象改变了其中的值，那另一个对象的值也跟着改变了

深拷贝：

      为每个对象都分配内存空间，防止析构时出现错误。

深拷贝的代码：

class String
{
public:
       String(const char* str = "")
              :_str(new char[strlen(str) + 1])
       {
              strcpy(_str, str);
       }
       String(const String& s)
       {
              //内存的拷贝先要创建出一块内存
              _str = new char[strlen(s._str)+1];
              //然后将指针所指向的内容拷贝一份
              strcpy(_str, s._str);
       }
       //赋值运算符的重载
       String& operator=(const String& s)
       {
              //防止自身对自身赋值（因为会delete掉原来的内存空间，如果是自己给自己赋值，那么delete以后就找不到了）
              if (this != &s)
              {
                     delete[] _str;
                     _str = new char[strlen(s._str) + 1];
                     strcpy(_str, s._str);
              }
              return *this;
       }
       ~String()
       {
              if (_str)
              {
                     delete[] _str;
              }
       }
private:
       char* _str;
};

深浅拷贝的不同：

      深浅拷贝的主要区别在于是否共用空间。两者的代码只有拷贝构造函数和赋值运算符重载时，深拷贝需要重新开辟空间，而浅拷贝仅仅改变了指针的指向。

深拷贝的缺点：

     重复的去开辟空间和释放空间效率是很低下的。

写时拷贝的引入：

     大家都知道，重复的开辟空间和释放内存是很耗时的，效率也很低下，相对于写时拷贝，深拷贝就很耗费时间了，效率自然没有写时拷贝好。

     写时拷贝是用一个计数器记住当前空间被多少个指针所指向，每次调用析构函数的时候，只需要看看自减后引用计数是否为零（是否只被最后一个指针所指向）。如果是，则销毁空间，如果不是，那么只需要引用计数减减即可，无需释放空间。

     写时拷贝是一种高性能的写法，不过这种写法如果不注意就会把引用计数弄错，导致错误。所以在写时拷贝的写法的时候，一定要小心改写引用计数。

执行下面的一段代码，写时拷贝写法的指针应该如何指向呢？

void test()
{
       String s1("hello");
       String s2(s1);
       String s3("world");
       s1 = s3;
}

图解上面的代码：

写时拷贝的代码：

class String
{
public:
       String(const char* str = "")
              :_str(new char[strlen(str)+1+4])//+1表示字符串后面要放一个'\0'，+4表示多开辟一个空间存放引用计数
       {
              _str += 4;//_str指向数据存放区
              strcpy(_str, str);
              _GetCount() = 1;//刚开始这里写成了_GetCount++,其实是不对的，因为引用计数所指向的这a块空间并没有初始化，他的值并不是0，是一个随机值，随机值++还是随机值
       }
       String(const String& s)
              :_str(s._str)
       {
              _GetCount()++;
       }
       String& operator=(String& s)
       {
              if (this != &s)
              {
                     if (--_GetCount() == 0)
                     {
                           delete[] (_str-4);
                     }
                     ++s._GetCount();
                     _str = s._str;
              }
              return *this;
       }
       ~String()
       {
              if (--_GetCount() == 0)
              {
                     delete[] (_str-4);
              }
       }
public:
       int& _GetCount()
       {
              return *((int*)_str-1);
       }
private:
       char* _str;
};