Copy_on_write的简单实现

最新推荐文章于 2024-11-28 14:58:24 发布

weixin_30307267

最新推荐文章于 2024-11-28 14:58:24 发布

阅读量172

点赞数

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/m4ch0/p/7040810.html

本文介绍了一种名为写时复制(Copy-on-write)的内存管理机制，并通过一个简单的字符串类实现来演示其工作原理。写时复制通过引用计数避免了不必要的内存拷贝，提高效率。

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

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

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

  1 #include <string.h>
  2 #include <iostream>
  3 using std::cout;
  4 using std::endl;
  5 
  6 class String 
  7 {
  8     public:
  9         String()
 10         : _pstr(new char[2]())
 11         {
 12             initRefcnt();
 13         }
 14 
 15         String(const char * pstr)
 16         : _pstr(new char[strlen(pstr)+2]())
 17         {
 18             strcpy(_pstr,pstr);
 19             initRefcnt();
 20         }
 21 
 22         String(const String &rhs)
 23         : _pstr(rhs._pstr)
 24         {
 25             increaseRefcnt();
 26         }
 27         
 28         String & operator=(const String & rhs)
 29         {
 30             if(this != &rhs) 
 31             {
 32                 decreaseRefcnt();
 33                 if(getRefcnt()==0)
 34                     delete [] _pstr;
 35                 _pstr = rhs._pstr;
 36                 increaseRefcnt();
 37             }
 38             return *this;
 39         }
 40 
 41         ~String()
 42         {
 43             decreaseRefcnt();
 44             if(getRefcnt()==0)
 45             {
 46                 delete [] _pstr;
 47                 cout << "~String()" << endl;
 48             }
 49         }
 50 
 51         size_t size() const
 52         {
 53             return strlen(_pstr);
 54         }
 55 
 56         const char * c_str() const
 57         {
 58             return _pstr;
 59         }
 60         
 61         size_t getRefcnt() const
 62         {
 63             return _pstr[size()+1];
 64         }
 65 
 66         char & operator[](size_t idx)
 67         {
 68             static char nullchar = '\0';
 69             if(idx < size())
 70             {
 71                 if(getRefcnt()>1)
 72                 {
 73                     decreaseRefcnt();
 74                     char * ptmp = new char[strlen(_pstr)+2];
 75                     strcpy(ptmp,_pstr);
 76                     _pstr = ptmp;
 77                     initRefcnt();
 78                 }
 79                 return _pstr[idx];
 80             }
 81             else
 82             {
 83                 cout << "Oops-->index cruptted!" << endl;
 84                 return nullchar;
 85             }
 86         }
 87 
 88     private:
 89         void initRefcnt()
 90         {
 91             _pstr[size()+1]=1;
 92         }
 93         void increaseRefcnt()
 94         {
 95             ++_pstr[size()+1];
 96         }
 97         void decreaseRefcnt()
 98         {
 99             --_pstr[size()+1];
100         }
101         friend std::ostream & operator<<(std::ostream & os,const String & rhs);
102 
103     private:
104         char * _pstr;
105 };
106 
107 std::ostream & operator<<(std::ostream & os,const String & rhs)
108 {
109     os << rhs._pstr;
110     return os;
111 }