WEB开发网
开发学院软件开发C++ More Effective C++之引用计数 阅读

More Effective C++之引用计数

 2008-03-08 12:53:24 来源:WEB开发网   
核心提示:Reference counting让我想起了java,当假如想用C++来实现Java的能力的话,More Effective C++之引用计数,那Reference counting必不可少,Reference counting可以节省程序的运行成本,想想Java,所以需要很谨慎的对待,大量的构造、析构、分配、释放和

  Reference counting让我想起了java,当假如想用C++来实现Java的能力的话,那Reference counting必不可少。Reference counting可以节省程序的运行成本,大量的构造、析构、分配、释放和拷贝的代价被省略。

  实现

classRCObject
{
 public:
  RCObject():refCount(0),shareable(true){}
  RCObject(constRCObject&):refCount(0),shareable(true){}
  RCObject& Operator=(constRCObject& rhs){return *this;}
  virtual ~RCObject()=0;
  void AddReference(){++refCount;}
  void RemoveReference(){if (--refCount == 0) deletethis;}

  void markUnshareable(){shareable = false;}
  bool isShareable() const{returnshareable;}
  bool isShared() const {returnrefCount > 1;}
 PRivate:
  int refCount;
  bool shareable;
};
RCObject::~RCObject(){}

template <classT>
class RCPtr
{
 public:
  RCPtr(T* realPtr = 0):pointee(realPtr){init();}
  RCPtr(constRCPtr& rhs):pointee(rhs.pointee){init();}
  ~RCPtr(){if (pointee) pointee->RemoveReference();}
  RCPtr& operator = (constRCPtr& rhs)
  {
   if (pointee!=rhs.pointee)
   {
    if (pointee)
     pointee->RemoveReference();
     pointee = rhs.pointee;
     init();
   }
   return *this;
  }
  T* operator->() const { returnpointee;}
  T& operator*() const{return *pointee;}
 private:
  T* pointee;
  void init()
  {
   if (pointee == 0)
    return;
   if (pointee->isShareable() == false)
    pointee = newT(*pointee);
   pointee->AddReference();
  }
};

class String
{
 public:
  String(const char* value = ""):value(newStringValue(value)){}
  const char& operator[](intnIndex) const
  {
   return value->data[nIndex];
  }
  char& operator[](intnIndex)
  {
   if (value->isShared())
    value = newStringValue(value->data);
    value->markUnshareable();
    returnvalue->data[nIndex];
  }
 protected:
 private:
  strUCt StringValue:publicRCObject
  {
   char* data;
   String Value(constchar* initValue)
   {
    init(initValue);
   }
   String Value(constStringValue& rhs)
   {
    init(rhs.data);
   }
   void init(constchar * initValue)
   {
    data = newchar[strlen(initValue) + 1];
    strcpy(data,initValue);
   }
   ~String Value()
   {
    delete [] data;
   }
  };
  RCPtr<StringValue> value;
};
  这是Meyers给出的String的实现,然而我的观点是假如没有非凡的必要的话,对stirng最好不要使用引用计数,因为在多线程程序中同步的代价要大于引用计数本身的好处,得不偿失。

  假如StringValue是一个现成的类,无法修改它的实现,那怎么办?没关系可以用委托,下面是一个典型的实现:


classRCObject
{
 public:
  RCObject():refCount(0),shareable(true){}
  RCObject(constRCObject&):refCount(0),shareable(true){}
  RCObject& operator=(constRCObject& rhs){return *this;}
  virtual ~RCObject()=0;
  void AddReference(){++refCount;}
  void RemoveReference(){if (--refCount == 0) deletethis;}

  void markUnshareable(){shareable = false;}
  bool isShareable() const{returnshareable;}
  bool isShared() const {returnrefCount > 1;}
 private:
  int refCount;
  bool shareable;
};
RCObject::~RCObject(){}

template<classT>
class RCiptr
{
 public:
  RCIPtr(T* realPtr = 0):counter(new CountHolder)
  {
   counter->pointee = realPtr;
   init();
  }
  RCIPtr(constRCIPtr& rhs):counter(rhs.counter)
  {
   init();
  }
  ~RCIPtr()
  {
   counter->RemoveReference();
  }
  RCIPtr& operator = (constRCIPtr& rhs)
  {
   if (counter != rhs.counter)
   {
    counter->RemoveReference();
    counter = rhs.counter;
    init();
   }
   return *this;
  }
  constT* operator->()const
  {
   returncounter->pointee;
  }
  T* operator->()
  {
   makeCopy();
   returncounter->pointee;
  }
  constT& operator*() const
  {
   return *(counter->pointee);
  }
  T& operator*()
  {
   makeCopy();
   return *(counter->pointee);
  }
 private:
  struct CountHolder:publicRCObject
  {
   ~Count Holder(){deletepointee;}
   T* pointee;
  };
  Count Holder* counter;
  void init()
  { 
   if (counter->isShareable() == false)
   {
    T* oldValue = counter->pointee;
    counter = newCountHolder;
    counter->pointee = newT(*oldValue);
   }
   counter->AddReference();
  }
  void makeCopy()
  {
   if (counter->isShared())
   {
    T* oldValue = counter->pointee;
    counter->RemoveReference();
    counter = newCountHolder;
    counter->pointee = newT(*oldValue);
    counter->AddReference();
   }
  }
 };
 class Widget
 {
  public:
   Widget(intSize){}
   Widget(constWidget& rhs){}
   ~Widget(){}
   Widget operator=(const Widget& rhs){}
   void doThis(){printf("doThis()\n");return;}
   int showThat() const{printf("showThat()\n"); return 0;}
  protected:
  private:
   inti;
 };

 class RCWidget
 {
  public:
   RCWidget(intsize):value(newWidget(size)){}
   void doThis(){value->doThis();}
   int showThat()const {returnvalue->showThat();}
  protected:
  private:
   RCIPtr<Widget> value;
};
  评估

  实现引用计数是需要有前提的,不是所有的情况下,使用引用计数都是合适的。适合情况如下:

  相对多的对象共享相对少量的实值。

  对象的实值产生或者销毁的成本很高,或者占用很多内存。

  但是要记住,即使是Java也会有内存泄漏,不要指望小小的引用计数(上面简单的实现)不会产生同样的问题。

  引用计数是一项很深奥的技术,想想Java,所以需要很谨慎的对待,但愿它能带来程序设计上的优化。

Tags:More Effective 引用

编辑录入:爽爽 [复制链接] [打 印]
赞助商链接