写时拷贝的两种方案

1. 什么是写时拷贝

写时拷贝故名思意：是在写的时候（即改变字符串的时候）才会真正的开辟空间拷贝（深拷贝），如果只是对数据的读时，只会对数据进行浅拷贝。
写时拷贝：引用计数器的浅拷贝，又称延时拷贝
：写时拷贝技术是通过"引用计数"实现的，在分配空间的时候多分配4个字节，用来记录有多少个指针指向块空间，当有新的指针指向这块空间时，引用计数加一，当要释放这块空间时，引用计数减一(假装释放)，直到引用计数减为0时才真的释放掉这块空间。当有的指针要改变这块空间的值时，再为这个指针分配自己的空间(注意这时引用计数的变化，旧的空间的引用计数减一，新分配的空间引用计数加一)。

2. string中的两种写时拷贝

一：

1. 动态开辟两个空间一个用来存放字符串：_str，一个用来存放计数器_refCountPtr
   
2. 每次拷贝构造时(赋值运算符的重载后半段)，直接把字符串的指针付给新的String，然后给计数器加加（*_refCountPtr）++
   
3. 在释放String的时候，先对计数器减减，再判断计数器是否为零（即看是否还有指针共享此内存），若计数器为零则直接释放_str 和 _refCountPtr
4. 在对字符串进行更改的时候(写时),就要进行深拷贝：先进行步骤3，在进行深拷贝和字符串的更改

class String//写时拷贝
    {
    public:
        String(char * str = "\0")
            :_refCountPtr(new int(1))//开辟计数器动态内存
            ,_size(strlen(str))
        {
            _capacity = _size;
            _str = new char[_capacity+1];//开辟字符串动态内存
            strcpy(_str,str);   
        }
        String(String& s)//拷贝构造
        :_str(s._str)//直接浅拷贝
        ,_refCountPtr(s._refCountPtr)
        ,_size(s._size)
        ,_capacity(s._capacity)
        {
            (*_refCountPtr)++;//但对计数器 ++
        }

        ~String()//析构
        {
            Release();
        }
        inline void Release()
        {
            if(--(*_refCountPtr) == 0)//计数器--，并判断是否为0
            {
                cout<<"~String"<<_str<<endl;
                delete[] _str；
                delete _refCountPtr;//释放    
            }
        }
        String &operator=(String &s)//重载
        {
            if(_str != s._str)//判断是否为自己给自己赋值
            {
                Release();//判断并处理this
                _str = s._str;
                _refCountPtr = s._refCountPtr;
                _size = s._size;
                _capacity = s._capacity;
                (*_refCountPtr)++;
            }
            return *this;
        }
        char *c_str() const
        {
            return _str;
        }
        //写时拷贝
        String &push_back(char ch)
        {
            char* str = new char[_capacity*2];
            strcpy(str,_str);
            //先将原来的数据保存，用于给后面重新开辟的空间赋值
            Release();//处理原来的空间
            _str = str;
            _str[_size++] = ch;
            _str[_size] = '\0';
            _capacity *= 2;
            _refCountPtr = new int(1);//
            return *this;
        }
    private:
        char *_str;
        int *_refCountPtr;
        size_t _size;
        size_t _capacity;
    };

二：

    开辟一个空间，前面4个字节为计数器count，剩下的为字符串_str的空间，用法与分开相同。

class String
    {
    public:
        String(char *str = "\0")
            :_capacity(strlen(str))
        {
            _size = _capacity;
            _str = new char[_capacity + 5];//多开辟了4个字节
            *(int *)_str = 1；//前4个自己存放计数器
            _str += 4;          //使_str指向开辟的4个字节后的空间
            strcpy(_str,str);//拷贝字符串
        }
        String(String &s)//拷贝构造
            :_str(s._str)//直接浅拷贝
            ,_capacity(s._capacity)
            ,_size(s._size)
        {
            ++(*(int *)(_str-4));//（str前的4个字节为计数器） ++
        }
        ~String()//析构
        {
            Release();
        }   
        void Release()
        {
            if(--(*(int *)(_str-4)) == 0)//计数器-1判断是否为零
            {
                cout<<"~String "<<_str<<endl;
                delete[] (_str-4);
            }
        }
        String& operator=(String &s)//赋值重载
        {
            if(_str != s._str)//判断是否为自己为自己赋值
            {
                Release();//处理原指针（释放空间，或者计数器-1）
                _str = s._str;
                _size = s._size;
                _capacity = s._capacity;//赋值
                ++(*(int *)(_str-4));//改变先指针的计数器
            }
            return *this;
        }
        String &operator+=(char ch)//重载，会改变，会深拷贝
        {
            char* str = new char[_capacity*2 + 6];
            strcpy(str+4, _str);//先保存原字符串
            Release();//因为要重新开辟空间，所以需要处理以前的空间
            *(int *)str = 1;//新开辟的计数器置1
            _str = str + 4;
            _str[_size++] = ch;
            _str[_size] = '\0';
            _capacity *= 2;
            return *this;
        }
        String &append(const char *str)//追加字符串
        {
            size_t len = strlen(str);//方法同+=的重载
            _capacity = len + _size;
            char *tmp = new char[_capacity + 6];
            strcpy(tmp+4 ,_str);
            Release();
            *(int *)tmp = 1;
            _str = tmp + 4;
            strcpy(_str+_size, str);
            _size = _capacity;
            return *this;
        }
    private:
        char* _str;//开辟多4个，指向4个字节后的地址
        size_t _size;
        size_t _capacity;
    };