Copy_on_write的简单实现

Copy_on_write即写时复制,它的原理是通过引用计数来实现的.

即在分配空间时多分配额外的空间,用来记录有多少个指针指向该空间.当有新的指针指向该空间,引用计数则加一,当要释放该空间时,引用计数则减一,直到引用计数减为0时,才真正释放该空间.当有指针要改变该空间的值时,再为这个指针分配自己的空间.而我们说的引用计数,存在于堆内存中.

下面的代码将实现简单的写时复制功能,如有错误欢迎指正.

 #include <string.h>
 #include <iostream>
 using std::cout;
 using std::endl;

 class String
 {
     public:
         String()
         : _pstr(new char[]())
         {
             initRefcnt();
         }

         String(const char * pstr)
         : _pstr(new char[strlen(pstr)+]())
         {
             strcpy(_pstr,pstr);
             initRefcnt();
         }

         String(const String &rhs)
         : _pstr(rhs._pstr)
         {
             increaseRefcnt();
         }

         String & operator=(const String & rhs)
         {
             if(this != &rhs)
             {
                 decreaseRefcnt();
                 if(getRefcnt()==)
                     delete [] _pstr;
                 _pstr = rhs._pstr;
                 increaseRefcnt();
             }
             return *this;
         }

         ~String()
         {
             decreaseRefcnt();
             if(getRefcnt()==)
             {
                 delete [] _pstr;
                 cout << "~String()" << endl;
             }
         }

         size_t size() const
         {
             return strlen(_pstr);
         }

         const char * c_str() const
         {
             return _pstr;
         }

         size_t getRefcnt() const
         {
             return _pstr[size()+];
         }

         char & operator[](size_t idx)
         {
             static char nullchar = '\0';
             if(idx < size())
             {
                 if(getRefcnt()>)
                 {
                     decreaseRefcnt();
                     char * ptmp = new char[strlen(_pstr)+];
                     strcpy(ptmp,_pstr);
                     _pstr = ptmp;
                     initRefcnt();
                 }
                 return _pstr[idx];
             }
             else
             {
                 cout << "Oops-->index cruptted!" << endl;
                 return nullchar;
             }
         }

     private:
         void initRefcnt()
         {
             _pstr[size()+]=;
         }
         void increaseRefcnt()
         {
             ++_pstr[size()+];
         }
         void decreaseRefcnt()
         {
             --_pstr[size()+];
         }
         friend std::ostream & operator<<(std::ostream & os,const String & rhs);

     private:
         char * _pstr;
 };

 std::ostream & operator<<(std::ostream & os,const String & rhs)
 {
     os << rhs._pstr;
     return os;
 }