C++写时拷贝

写时拷贝copy on write

**首先什么时候会用到写时拷贝呢？
答：顾名思义修改的时候才拷贝,是为了解决浅拷贝的坑和平衡内存开销大而出的解决方案。

浅拷贝的坑——就是多个对象共用同一地址，在析构时同一块空间被释放多次，这种情况是不被允许的。

内存开销大——就是在每一次 深拷贝 时系统会新开辟空间，用来存放新对象。每创建一个新对象，就会开辟空间。每新开辟空间自然就会占内存，就会存在内存开销╮(╯_╰)╭。

深拷贝——就是为了“填浅拷贝的坑”，为新对象开辟新空间。

为了防止多次析构，但是还要考虑内存开销。我们想到用 引用计数（_refCount） 来起到一个内存使用的记录作用，让使用者清楚这块空间被who共用。在这块空间被析构时保证只有一个对象使用，即引用计数是1。当引用计数为0，这块空间真正被释放。

引用计数——即防止多个对象用一块空间时，这块空间被多次释放，用到的一个计数器。

#define _CRT_SECURE_NO_WARNINGS#include<iostream>#include<cstdio>using namespace std;namespace COW{    class String    {    public:        String(const char* str)            :_str(new char[strlen(str) + 1])            , _refCount(new int(1))        {            strcpy(_str, str);        }        // s2(s1)        String(String& s)        {            _str = s._str;            _refCount = s._refCount;            ++(*_refCount);        }        // s2 = s4        String& operator=(const String& s)        {            if (_str != s._str)            {                Release();                _str = s._str;                _refCount = s._refCount;                (*_refCount)++;            }            return *this;        }        void Release()        {            if (--(*_refCount) == 0)            {                cout << "delete" << endl;                delete[] _str;                delete _refCount;            }        }        char& operator[](size_t pos)        {            CopyOnWrite();            return _str[pos];        }        char operator[](size_t pos) const        {            return _str[pos];        }        void CopyOnWrite()        {            if (*_refCount > 1)            {                char* tmp = new char[strlen(_str) + 1];                strcpy(tmp, _str);                --(*_refCount);                _str = tmp;                _refCount = new int(1);            }        }        // Insert        // Erase        ~String()        {            Release();        }    private:        char* _str;        int* _refCount;    };

这里测试时：

void TestString()    {        String s1("hello world");        String s2(s1);        String s3(s1);        String s4("aaaaaaaaaaa");        String s5(s4);        s2 = s4;    }

对于这个例子，我们还可以做一个优化，可以模仿new[]底层实现来开辟空间，让引用计数占用前四个字节的空间 。

优化代码如下：

#define _CRT_SECURE_NO_WARNINGS#include<iostream>#include<cstdio>using namespace std;namespace COW{    class String    {    private:        char*_str;    public:        String(const char* str)            :_str(new char[strlen(str) + 5])        {            //*((int*)_str) = 1;            _str += 4;            strcpy(_str, str);            GetRefCount()=1;        }        int& GetRefCount()        {            return *((int*)(_str - 4));        }        ~String()        {            //if (--*((int*)_str - 4) == 0)            if (--GetRefCount()==0)            {                cout << "delete" << endl;                delete[](_str - 4);            }        }        String(const String&s)            :_str(s._str)        {            //(*(int*)(_str - 4))++;            ++GetRefCount();        }        String& operator=(const String& s)        {            if (_str != s._str)            {                if (--GetRefCount() == 0)                {                    delete[](_str - 4);                }                _str = s._str;                GetRefCount()++;            }            return *this;        }        const  char* GetStr()        {            return _str;        }    };    void TestString()    {        String s1("hello");        cout << s1.GetStr() << endl;        String s2 = s1;        cout << s2.GetStr() << endl;    }}