小结 | C++ String类的引用计数的浅拷贝、写时拷贝

这篇博客将一步一步写出写实拷贝的的思路，以模拟实现string类为例子

1、深浅拷贝

#include <iostream>#include <stdlib.h>class String{public:    String(const char* str = "")        :_str(new char[strlen(str)+1])    {        strcpy(_str, str);    }    //浅拷贝    String(const String&s)    {        _str = s._str;    }    ////深拷贝    //String(const String&s)    //  :_str(new char[strlen(s._str)+1])    //{    //  strcpy(_str, s._str);    //}    ~String()    {        if (_str)        {            delete[] _str;        }    }private:    char*_str;};int main(){    String s1("123455");    String s2(s1);    return 0;}

上面的程序使用浅拷贝将会崩溃。因为浅拷贝是直接指向了同一块空间，在调用析构函数的时候会对同一块空间delete[]了两次。这样是不合法的。使用深拷贝将会没有任何问题。

使用了深拷贝，其实就是另外开辟一块空间，再将原来空间的值拷贝下来。

2、引用计数的浅拷贝

如果我们不想用深拷贝，因为深拷贝会开辟空间，这样浪费空间，同时还影响效率。那么我们就可以使用引用计数的浅拷贝。引用计数的浅拷贝指的是当一个类还有对象存在的时候，就不进行析构。这样就避免对同一块空间的多次delete[]。

（1）引入static _refcount当做计数器

class String{public:    String(const char* str = "")        :_str(new char[strlen(str)+1])    {        strcpy(_str, str);    }    //浅拷贝    String(const String&s)    {        _str = s._str;        _refcount++;//进行拷贝构造，增加引用计数的个数    }    ~String()    {        if (--_refcount == 0)        {            delete[] _str;        }    }private:    char*_str;    static int _refcount;//定义为静态的};int String::_refcount = 1;//静态全局变量需要在类外面初始化

定义为静态的_refcount 是为了让对象共用一个。而不是每一个对象都有一个引用计数。
这样似乎是对的，但是一个类可以同时开辟出多个对象，这多个对象都有自己的空间，但是使用了静态的_refcount的话，他们都共有一个引用计数，这样依然会对同一块空间有多次的delete[]。

（2）使用指针类型的_refcount

为了克服以上的问题，我们打算开辟一个整型大小空间，用int* ——refcount维护这块空间。这样就可以保证每一块空间搭配一个引用计数，同时同一个对象拷贝构造出来的使用的是同一个引用计数。

class String{public:    String(const char* str = "")        :_str(new char[strlen(str) + 1])        , _refcount(new int(1))    {        strcpy(_str, str);    }    String(const String& s)        :_str(s._str)    {        _refcount = s._refcount;        (*_refcount)++;    }    //s1 = s2    String& operator=(const String& s)    {        if (_str != s._str)        {            if (--(*_refcount) == 0)            {                delete[] _str;                delete _refcount;                _str = NULL;                _refcount = NULL;            }            _str = s._str;            _refcount = s._refcount;            ++(*_refcount);        }        return *this;    }    ~String()    {        if (--(*_refcount) == 0)        {            delete[] _str;            delete _refcount;            _str = NULL;            _refcount = NULL;        }    }private:    char* _str;    int* _refcount;};int main(){    String s1("123455");    String s2(s1);    String s3(s2);    //创建新的空间    String s4("0009");    String s5(s4);    return 0;}      

s1\s2\s3指向同一块空间，共用一个引用计数。s4\s5指向另外一块空间，共用另一个引用计数

（3）将引用计数放到开辟空间的前面

使用指针的引用计数是一种好的方式，但是这样会增加内存空间的碎片化。为了解决内存碎片化，我们可以在开辟的_str 空间的前面多开一个int大小的空间，用作存放引用计数。模仿new[]的做法。

修改代码如下：

class String{public:    String(const char* str = "")        //strlrn(str) + 1是给'\0'留下的空间，+4是给引用计数        :_str(new char[strlen(str) + 1 + 4])    {        *((int*)_str) = 1;        //让_str指向引用计数之后的空间，即字符串的开始        _str += 4;        strcpy(_str, str);    }    String(const String& s)        //让_str指向引用计数        :_str(s._str-4)    {        //引用计数加一        (*((int*)_str))++;        _str += 4;    }    //s1 = s2    String& operator=(const String& s)    {        if (_str != s._str)        {            //引用计数减一判0            if (--(*((int*)_str-1)) == 0)            {                delete[] _str;                _str = NULL;            }            _str = s._str;            //引用计数加一            (*((int*)s._str - 1))++;        }        return *this;    }    ~String()    {        if (--(*((int*)_str - 1)) == 0)        {            delete[] _str;            _str = NULL;        }    }private:    char* _str;};int main(){    String s1("123455");    String s2(s1);    String s3(s2);    String s4("0009");    String s5(s4);    return 0;}      

至此，我们的引用计数的浅拷贝已经完成的很好了。

3、写时拷贝

有一个问题，因为s1、s2同时指向了同一块空间，如果我对s1进行了值的修改，必定会同时修改了s2的值。我们不希望这事情的发生，因此我们引入了写时拷贝。写时拷贝的意思是，当我需要向空间写入值的时候，即修改值的时候，我们就将修改的对象拷贝一份出来。这样就不会影响到其他的对象了。

void CopyOnWrite(){    if (*((int*)_str-1) > 1)    {        (*((int*)_str - 1))--;        char* tmp = new char[strlen(_str) + 5];        tmp -= 4;        strcpy(tmp, _str);        _str = tmp;        (*((int*)_str+1))++;    }}