String-引用计数的写时拷贝

【写时拷贝】
何为写时拷贝呢？？？
提到写时拷贝就不得不提起浅拷贝和深拷贝，深拷贝补充了浅拷贝的不足，而写时拷贝补充了深拷贝的不足，那么到底是怎么补充的呢？下面，给大家细细道来。
其实写时拷贝就是当你读取到这个已经存在的空间时，并不会立刻开辟出一个一模一样的空间出来给你，而是用计数的方式来延迟拷贝，当你真正需要拷贝的时候，才会开辟空间给你。也就是延迟的深拷贝。
下面来看看浅拷贝和深拷贝是怎么实现的：
1.浅拷贝
浅拷贝是指源对象与拷贝对象共用一份实体，仅仅是引用的变量不同（名称不同）。
用草图来解释更直观：

下面看浅拷贝的代码：

#include<iostream>
using namespace std;
class AA
{
...
};

int main(void)
{
    AA a1;
    AA a2(a1);
    return 0;
}

浅拷贝的缺陷：我们看到对象a1和a2地址一样，指向同一块空间，当类中的成员变量包括指针时，而又没有定义自己的拷贝构造函数，那么在拷贝一个对象的情况下，就会调用其默认拷贝构造函数，这个函数只是对其成员变量做了个简单的拷贝，即位拷贝，它们指向的还是同一块存储空间，当调用析构函数时，就会多次析构造成程序崩溃。
2.深拷贝
深拷贝是为了解决浅拷贝中同一快空间多次释放的问题。
深拷贝是自己重新开一块空间，将源空间的数据拷贝到新的空间，从而实现拷贝。

代码如下：

String(const String& str)
{
    _str=new char[strlen(str._str)+1];
    strcpy(_str,str._str);
}

this->_str拥有了自己的一块空间。
【深拷贝的现代写法】

String(const String& str)
{
    _str=NULL;
    String tmp(str._str);
    swap(_str,tmp._str);
}

3.写实拷贝
从上面的浅拷贝和深拷贝中，我们看到了它们俩的很多问题，那么写实拷贝就很好了解决了这些问题，那么它是如何解决的呢？
写实拷贝有两种方式：
方式一：
在浅拷贝的基础上，在创建一个指针变量的空间，用来计数控制析构来实现拷贝。

代码：

class String1
{
public:
    String1(const char* str = ) //构造函数
       ：_str(new char[strlen(str)+1])
       ,_refCount(new int(1))
    {
        strcpy(_str,str);
    }
      String1(String1&  s)//拷贝构造
          :_str(s._str)
          ,_refCount(s._refCount)
      {
           (*refCount)++;
      }

      ~String1()
      {
          if(--(*_refCount)==0)
          {
              delete[] _str;
              delete _refCount;
          }

      }

private:
    char* _str;
    int* _refCount;
};

当然，考虑到赋值运算符的重载时要考虑多种情况：

具体代码如下：

String1 & operator=(const String1& s)
{
    if(_str!=s._str)
    {
        if(--(*_refCount)==0)
        {
            delete[] _str;
            delete _refCount;
        }
        _str=s._str;
        _refCount=s._refCount;
        *(_refCount)++;
    }
    return *this;
}

写时拷贝：

void CopyOnWrite()
{
    if(*_refCount>1)
    {
        char * newstr=new char[strlen(_str)];
        strcpy(newstr,_str);
        (*_refCount)--;
        _str=newstr;
        _refCount=new int(1);
    }
}

方式二：
开辟一个空间，前面4个字节为计数器count，剩下的为字符串_str的空间
代码实现如下：

String(const char* str=)
  :_str(new char[strlen(str)+5]) 
{
   strcpy(_str+4,str);
   *((int*)_str)=1;
   _str+=4;
}       

String(const String&s)
:_str(s._str)
{
    (*(int*)(_str-4))++;
}

~String()
{
    if(--*((int*)(_str-4))==0)
    {
        delete[] (_str-4);
    }
}

String& operator=(const String& s)
{
    if(_str!=s._str)
    {
        if(--GetRefCount()==0)
        {
            delete[](_str-4);
        }
        _str=s._str;
        GetRefCount()++;
    }

    return *this;
}

int& GetRefCount()
{
    return (*(int*)(_str-4));
}