写一个CopyOnWrite的通用实现(C++)

这项技术最常用的是字符串类，如下：
string s1 ("long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long long string");
string s2 = s1;   /
如果直接复制字符串缓冲区，那么会极大地损失效率，所以一般不这么做，而是让2个字符串共享同一个数据，当某个字符串对象要修改缓冲区时，再给它复制一份。

实现了一个简单的CopyOnWrite类，并用vector模拟了一个字符串，当然还没写完它，也只模拟了CopyOnWrite部分。

---

#include  < vector >
#include  < iostream >
#include  < cassert >
using   namespace  std;

#define  DEBUG_TEST

#ifdef DEBUG_TEST
# define TRACE1(x) cout  <<  x  <<  endl
# define TRACE2(x,y) cout  <<  x  <<  y  <<  endl
#endif

template  < typename T >
class  CopyOnWriteData
{
    size_t    _ref_count;
    T        _data;

    CopyOnWriteData ( const  CopyOnWriteData &  data)
        : _ref_count ( 1 ), _data(data._data)
    {
        TRACE2 ( " CopyOnWriteData (const CopyOnWriteData& data) |  " ,  this );
    }

    CopyOnWriteData &   operator   =  ( const  CopyOnWriteData &  data);
public :
    CopyOnWriteData ()
        : _ref_count ( 0 )
    {
        TRACE2 ( " CopyOnWriteData () |  " ,  this );
    }

    CopyOnWriteData (T data)
        : _ref_count ( 1 ), _data(data)
    {
        TRACE2 ( " CopyOnWriteData (T data) |  " ,  this );
    }

     ~ CopyOnWriteData ()
    {
        TRACE2 ( " ~CopyOnWriteData () |  " ,  this );
        release ();
    }

    CopyOnWriteData *  copy ()
    {
        CopyOnWriteData *  cp  =   new  CopyOnWriteData ( * this );
        release ();
         return  cp;
    }

    T &  data ()
    {
         return  _data;
    }

    size_t ref_count ()  const
    {
         return  _ref_count;
    }

    size_t addRef ()
    {
         return   ++  _ref_count;
    }

    size_t release ()
    {
         return   --  _ref_count;
    }
};

template  < typename T >
struct  CopyOnWrite
{
    CopyOnWriteData < T >*  holder;

     void  auto_copy ()
    {
         if  (holder -> ref_count ()  >   1 )
            holder  =  holder -> copy ();
    }

    CopyOnWrite (CopyOnWriteData < T >*  p  =   0 )
        : holder (p)
    {
        TRACE2 ( " CopyOnWrite (CopyOnWriteData<T>* p = 0) |  " ,  this );
         if  (holder)
            holder -> addRef ();
    }

    CopyOnWrite ( const  CopyOnWrite &  o)
        : holder (o.holder)
    {
        TRACE2 ( " CopyOnWrite (const CopyOnWrite& o) |  " ,  this );
         if  (holder)
            holder -> addRef ();
    }

    CopyOnWrite &   operator   =  ( const  CopyOnWrite &  o)
    {
        TRACE2 ( " CopyOnWrite& operator = (const CopyOnWrite& o) |  " ,  this );
        cout  <<   ""   <<   this   <<  endl;
        holder  =  o.holder;
         if  (holder)
            holder -> addRef ();
         return   * this ;
    }

     ~ CopyOnWrite ()
    {
        TRACE2 ( " ~CopyOnWrite () |  " ,  this );
         if  (holder)
            holder -> release ();
         if  ( ! holder -> ref_count ())
            delete holder;
    }
};

class  String
{
#ifdef DEBUG_TEST
public :
#endif
    CopyOnWrite  < vector < char >   >  _data;
public :
    String ( const   char *  p  =   0 )
    {
        TRACE2 ( " String (const char* p = 0) |  " ,  this );
        _data.holder  =   new  CopyOnWriteData < vector < char >   > ;
         if  ( ! p)
        {
            _data.holder -> data ().push_back ( ' \0 ' );
        }
         else
        {
            size_t len  =  strlen(p)  +   1 ;
            copy (p, p  +  len, back_insert_iterator  < vector < char >   >  (_data.holder -> data ()));
        }
        _data.holder -> addRef ();
    }

    String ( const  String &  o)
        : _data (o._data)
    {
        TRACE2 ( " String (const String& o) |  " ,  this );
    }

    String &   operator   =  ( const  String &  o)
    {
        TRACE2 ( " String& operator = (const String& o) |  " ,  this );
        _data  =  o._data;
         return   * this ;
    }

     ~ String ()
    {
        TRACE2 ( " ~String () |  " ,  this );
    }

     const   char *  c_str ()  const
    {
         return  ( const   char * ) & _data.holder -> data ()[ 0 ];
    }

    size_t find ( const   char *  fstr)  const
    {
         //  
    }

     void  append ( const   char *  p)
    {
        _data.auto_copy ();
         //  
    }
};

int  _tmain( int  argc, _TCHAR *  argv[])
{
    String s ( " hello " );
    assert (s._data.holder -> ref_count ()  ==   1 );
    String s1  =  s;

    assert (s._data.holder -> ref_count ()  ==   2 );
    assert (s1._data.holder -> ref_count ()  ==   2 );
    String s2 (s);
    assert (s._data.holder -> ref_count ()  ==   3 );
    assert (s1._data.holder -> ref_count ()  ==   3 );
    assert (s2._data.holder -> ref_count ()  ==   3 );

    assert (strcmp ( " hello " , s.c_str ())  ==   0 );

    assert (s._data.holder  ==  s1._data.holder);
    assert (s2._data.holder  ==  s1._data.holder);

    s.append ( " aa " );
    assert (s._data.holder -> ref_count ()  ==   1 );
    assert (strcmp ( " hello " , s.c_str ())  ==   0 );
    assert (s1._data.holder -> ref_count ()  ==   2 );
    assert (strcmp ( " hello " , s.c_str ())  ==   0 );
    assert (s2._data.holder -> ref_count ()  ==   2 );
    assert (strcmp ( " hello " , s.c_str ())  ==   0 );

     return   0 ;
}

转载于:https://www.cnblogs.com/cpunion/archive/2005/07/29/202677.html