写时拷贝（Copy On Write）方案详解

本文旨在通过对 写时拷贝 的四个方案（Copy On Write）分析，让大家明白写时拷贝的实现及原理。

关于浅拷贝与深拷贝，我在之前的博客中已经阐述过了 

浅拷贝容易出现指针悬挂的问题，深拷贝效率低，但是我们可以应用引用计数来解决浅拷贝中多次析构的问题，写时拷贝也就应运而生了。

首先要清楚写时拷贝是利用浅拷贝来解决问题！！

方案一

class String
{
private:
    char* _str;
    int _refCount;
};

方案一最不靠谱，它将用作计数的整形变量_refCount定义为类的私有成员变量，任何一个对象都有它自己的成员变量_refCount，它们互不影响，难以维护。只要拷贝出了对象，_refCount大于了0，每个对象在调用自己的析构函数时--_refCount不等于0，那么它们指向的那块内存都将得不到释放，无法达到我们要的效果。

//以下是对方案一的简单实现，大家可以结合上图感受到方案一的缺陷
 
class String
{
public:
    String(char* str = "")    //不能strlen（NULL）
       :_refCount(0)
    {
       _str = new char[strlen( str) + 1];
       strcpy(_str, str);
       _refCount++;
    }
    String(String &s)
       :_refCount( s._refCount)     
    {
       _str = s._str;
       _refCount++;
       s._refCount = _refCount;
        
       //这里虽然可以让两个对象的_refCount相等，
       //但如果超过两个对象的_str指针都指向同一块内存时，
       //就无法让所有对象的_refCount都保持一致
       //这是方案一的缺陷之一
    }
    ~String()
    {
       if (--_refCount == 0)
       {
            delete[] _str;
           _str = NULL;
           cout << "~String " << endl;
       }
    }
    friend ostream& operator<<( ostream& output, const String &s);
private:
    char* _str;
    int _refCount;
};
ostream& operator<<( ostream& output, const String & s)
{
    output << s._str;
    return output;
}
void Test()
{
    String s1("aaa");
    String s2(s1);
    String s3(s2);
    cout << s1 << endl;
    cout << s2 << endl;
    cout << s3 << endl;
}　

方案二

class String
{
private:
    char* _str;
    static int count;
};

设置了一个静态整形变量来计算指向一块内存的指针的数量，每析构一次减1，直到它等于0（也就是没有指针在指向它的时候）再去释放那块内存，看似可行，其实不然！

这个方案只适用于只调用一次构造函数、只有一块内存的情形，如果多次调用构造函数构造对象，新构造的对象照样会改变count的值，那么以前的内存无法释放会造成内存泄漏。

 

结合上图和下面的代码，我们可以清楚地看到该方案相比方案一的改善，以及缺陷

class String
{
public:
    String(char* str = "")    //不能strlen（NULL）
    {
       _str = new char[strlen( str) + 1];
       strcpy(_str, str);
 
       count++;
    }
    String(const String &s)
    {
       _str = s._str;
       count++;
        
    }
    String& operator=( String& s)  
    {
       _str = s._str;
       count++;
       return *this;
    }
    ~String()
    {
       if (--count == 0)
       {
            delete[] _str;
           _str = NULL;
           cout << "~String " << endl;
       }
    }
    friend ostream& operator<<( ostream& output, const String &s);
    friend istream& operator>>( istream& input, const String &s);
private:
    char* _str;
    static int count;
};

int String::count = 0;      //初始化count

void Test()    //用例测试
{
    String s1("abcdefg");
    String s2(s1);
    String s3;
    s3 = s2;
    cout << s1 << endl;
    cout << s2 << endl;
    cout << s3 << endl;
 
    String s4("opqrst");
    String s5(s4);
    String s6 (s5);
    s6 = s4;
    cout << s4 << endl;
    cout << s5 << endl;
    cout << s6 << endl; 
}

方案三

问题的关键是，我们不是要为每一个对象建立一个引用计数，而是要为每一块内存设置一个引用计数，只有这样才方便我们去维护。当指向这块内存的指针数为0时，再去释放它！

class String
{
    private:
               char* _str;
               int* _refCount;      
};

方案三设置了一个int型的指针变量用来引用计数，每份内存空间对应一个引用计数，而不是每个对象对应一个引用计数，而且内存之间的引用计数互不影响，不会出现方案一和方案二出现的问题。

1.在实现赋值运算符重载时要谨慎，不要遇到下图的情形

 s1指向内存1，s2指向内存2，利用s2拷贝出的对象s3也指向内存块2，这时候内存块1的引用计数等于1 ，内存块2的引用计数等于2。一切似乎都很正常，但是调用赋值运算符重载执行语句：s2=s1后，错误慢慢显现出来了。将s2指向内存1 并把内存1 的引用计数加1，这理所当然，但是不能把s2原本指向的空间直接delete，s3还指向内存2着呢！这里千万在释放一块空间前，对指向这块内存的引用计数进行检查，当引用计数为0的时候再去释放，否则只做减引用计数就行。

 //错误代码
String& operator=(String& s)  
    {
        if (_str!= s._str)
        {
            delete[] _str;
            delete _refCount;          
            _str = s._str;
            _refCount = s._refCount;
            (*_refCount)++;
        }      
        return *this;
    }　

2.改变字符串的某个字符时要谨慎，不要遇到类似下图所遇到的问题。

如果多个对象都指向同一块内存，那么只要一个对象改变了这块内存的内容，那所有的对象都被改变了！！

如下图：当s1和s2都指向内存块1，s3经过赋值运算符重载后也指向内存块1，现在s2如果对字符串进行修改后，所有指向内存块1 的指针指向的内容都会被改变！

可以用下图的形式改善这种问题：新设置一块内存来存要改变的对象，这样就不会影响其他的对象了

案例3我画的图较多，方便大家结合代码去理解 

//案例三
class String
{
public:
    String(char* str = "")    //不能strlen（NULL）
    {
        _refCount = new int(1);     //给_refCount开辟空间，并赋初值1
        _size = strlen(str);
        _capacity = _size + 1;
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }
    String(const String &s)
    {
        _refCount = s._refCount;
        _str = s._str;
        _size = strlen(s._str);
        _capacity = _size + 1;
        (*_refCount)++;      //拷贝一次_refCount都要加1
         
    }
     
    //要考虑是s1=s2时，s1原先不为空的情况，要先释放原内存
    //如果要释放原内存时，要考虑它的_refCount减1后是否为0，为零再释放，否则其它对象指针无法再访问这片空间
    String& operator=(String& s)  
    {
        if (_str!= s._str)
        {
            _size = strlen(s._str);
            _capacity = _size + 1;
            if (--(*_refCount) == 0)
            {
                delete[] _str;
                delete _refCount;
            }
             
            _str = s._str;
            _refCount = s._refCount;
            (*_refCount)++;
        }      
        return *this;
    }

    //如果修改了字符串的内容，那所有指向这块内存的对象指针的内容间接被改变
    //如果还有其它指针指向这块内存，我们可以从堆上重新开辟一块内存空间，
    //把原字符串拷贝过来
    //再去改变它的内容，就不会产生链式反应
    //  1.减引用计数  2.拷贝   3.创建新的引用计数
    char& String::operator[](const size_t index) //参考深拷贝      
    {
        if (*_refCount==1)
        {
            return *(_str + index);
        }
        else
        {
            --(*_refCount);
            char* tmp = new char[strlen(_str)+1];
            strcpy(tmp, _str);
            _str = tmp;
            _refCount = new int(1);
            return *(_str+index);
        }
    }
    ~String()
    {
        if (--(*_refCount)== 0)  //当_refCount=0的时候就释放内存
        {
            delete[] _str;
            delete _refCount;
            _str = NULL;
            cout << "~String " << endl;
        }
        _size = 0;
        _capacity = 0;
    }
    friend ostream& operator<<(ostream& output, const String &s);
    friend istream& operator>>(istream& input, const String &s);
private:
    char* _str;      //指向字符串的指针
    size_t  _size;      //字符串大小
    size_t  _capacity;   //容量
    int* _refCount;    //计数指针
};
 
 
ostream& operator<<(ostream& output, const String &s)
{
    output << s._str;
    return output;
}
istream& operator>>(istream& input, const String &s)
{
    input >> s._str;
    return input;
}
 
void Test()    //用例测试
{
    String s1("abcdefg");
    String s2(s1);
    String s3;
    s3 = s2;
    cout << s1 << endl;
    cout << s2 << endl;
    cout << s3 << endl;
    s2[3] = '0';
    cout << s1 << endl;
    cout << s2 << endl;
    cout << s3 << endl;
}
　

方案四

class String
{
   private:
           char* _str;
};

 

方案四与方案三类似。方案四把用来计数的整型指针变量放在所开辟的内存空间的首部。

用*((int*)_str)就能取得计数值

class String
{
public:
           String(char * str = "" )    //不能strlen（NULL）
           {
                    _str = new char[strlen( str) + 5];
                    _str += 4;
                    strcpy(_str, str);
                    GetRefCount(_str) = 1;
           }
           String(const String &s)
           {
                    _str = s._str;
                    ++GetRefCount(_str);
           }
 
           //要考虑是s1=s2时，s1原先不为空的情况，要先释放原内存
           //如果要释放原内存时，要考虑它的_refCount减1后是否为0，
           //为零再释放，否则其它对象指针无法再访问这片空间
           String& operator=(String& s)
           {
                    if (this != &s )
                    {
                              if (GetRefCount(_str ) == 1)
                              {
                                       delete (_str-4);
                                       _str = s._str;
                                       ++GetRefCount(_str );
                              }
                              else
                              {
                                       --GetRefCount(_str );
                                       _str = s._str;
                                       ++GetRefCount(_str );
                              }
                    }
                    return *this ;
           }
           //如果修改了字符串的内容，那所有指向这块内存的对象指针的内容间接被改变
           //如果还有其它指针指向这块内存，我们可以从堆上重新开辟一块内存空间，
           //把原字符串拷贝过来.
           //再去改变它的内容，就不会产生链式反应
            
          
           char& String ::operator[](const size_t index ) //深拷贝     
           {
                    
                              if (GetRefCount(_str) == 1)
                              {
                                       return _str[index ];
                              }
                              else
                              {
                                        //  1.减引用计数
                                       --GetRefCount(_str );
                                        //  2.拷贝     3.创建新的引用计数
                                       char* tmp = new char [strlen(_str) + 5];   
                                      *((int *)tmp) = 1;
                                       tmp += 4;
                                       strcpy(tmp, _str);
                                       _str = tmp;
                                       return _str[index ];
                              }
           }
 
           int& GetRefCount(char* ptr)    //获取引用计数(隐式内联函数)
           {
                    return *((int *)(ptr -4));
           }
           ~String()
           {
                    if (--GetRefCount(_str) == 0)
                    {
                              cout << "~String" << endl;
                              delete[] (_str-4);             
                    }
           
           }
           friend ostream& operator<<( ostream& output, const String &s);
           friend istream& operator>>( istream& input, const String &s);
private:
           char* _str;
 
};
 
 
ostream& operator<<(ostream& output, const String &s)
{
           output << s._str;
           return output;
}
istream& operator>>(istream& input, const String &s)
{
           input >> s._str;
           return input;
}
 
void Test()  //用例测试
{
           String s1("abcdefg" );
           String s2(s1);
           String s3;
           s3 = s2;
           cout << s1 << endl;
           cout << s2 << endl;
           cout << s3 << endl;
           s2[3] = '0';
           cout << s1 << endl;
           cout << s2 << endl;
           cout << s3 << endl;
}