引用计数的使用

在现存类上增加引用计数

我们如何让一个位于支撑库中而无法修改的类获得引用计数的好处呢？

我们现在可以应用这句格言：计算机科学中的绝大部分问题都可以通过增加一个中间
层次来解决。

RCWidget是给用户使用的类，RCOBject是操作引用计数的，CountHoler是一个中间层，Widget是需要添加引用计数的类

RCObjcet可以被构造（作为派生类的基类部分）和析构；可以有新的引用加在上面以
及移除当前引用；其可共享性可以被查询以及被禁止；它们可以报告当前是否被共享了。这就是它所提供的功能。对于想有引用计数的类，这确实就是我们所期望它们完成的东西。注意虚析构函数，它明确表明这个类是被设计了作基类使用的。同时要注意这
个析构函数是纯虚的，它明确表明这个类只能作基类使用。

类的定义是：

class RCObject {                       // base class for reference- 
public:                                // counted objects 
  void addReference(); 
  void removeReference(); 
  void markUnshareable();   bool isShareable() const; 
  bool isShared() const; 

protected: 
  RCObject(); 
  RCObject(const RCObject& rhs); 
  RCObject& operator=(const RCObject& rhs); 
  virtual ~RCObject() = 0; 

private: 
  int refCount; 
  bool shareable; 
}; 

类的实现：

RCObject::RCObject() 
: refCount(0), shareable(true) {}

 
RCObject::RCObject(const RCObject&) 
: refCount(0), shareable(true) {} 

RCObject& RCObject::operator=(const RCObject&) 
{ 

return *this;

 } 

RCObject::~RCObject() {} 

void RCObject::addReference() 

{ 

++refCount; 

} 

void RCObject::removeReference() 
{

 if (--refCount == 0) 

delete this;

 } 

void RCObject::markUnshareable() 
{ 

shareable = false; 

} 

bool RCObject::isShareable() const 
{ 

return shareable;

 } 

bool RCObject::isShared() const 
{

 return refCount > 1; 

} 

template<class T> 

class RCIPtr { 

public: 
  RCIPtr(T* realPtr = 0); 

  RCIPtr(const RCIPtr& rhs); 
  ~RCIPtr(); 
  RCIPtr& operator=(const RCIPtr& rhs); 
  const T* operator->() const;               // see below for an 
  T* operator->();                           // explanation of why 
  const T& operator*() const;                // these functions are 
  T& operator*();                            // declared this way 

private: 
  struct CountHolder: public RCObject

 { 
    ~CountHolder() { 

delete pointee;

 } 

    T *pointee; 
  }; 

  CountHolder *counter; 
  void init(); 
  void makeCopy();                                // see below 
}; 

template<class T> 
void RCIPtr<T>::init() 
{ 
  if (counter->isShareable() == false) { 
    T *oldValue = counter->pointee; 
    counter = new CountHolder; 
    counter->pointee = new T(*oldValue); 
  } 
  counter->addReference(); 
} 

template<class T> 
RCIPtr<T>::RCIPtr(T* realPtr) 
: counter(new CountHolder) 
{ 
  counter->pointee = realPtr;   init(); 
} 

template<class T> 
RCIPtr<T>::RCIPtr(const RCIPtr& rhs) 
: counter(rhs.counter) 
{ init(); } 

template<class T> 
RCIPtr<T>::~RCIPtr() 
{ counter->removeReference(); } 

template<class T> 
RCIPtr<T>& RCIPtr<T>::operator=(const RCIPtr& rhs) 
{ 
  if (counter != rhs.counter) { 
    counter->removeReference(); 
    counter = rhs.counter; 
    init(); 
  } 
  return *this; 
} 

template<class T>                          // implement the copy 
void RCIPtr<T>::makeCopy()                 // part of copy-on- 
{                                          // write (COW) 
  if (counter->isShared()) { 
    T *oldValue = counter->pointee; 
    counter->removeReference(); 
    counter = new CountHolder; 
    counter->pointee = new T(*oldValue); 
    counter->addReference(); 
  } 
} 

template<class T>                           // const access; 
const T* RCIPtr<T>::operator->() const      // no COW needed 
{ return counter->pointee; } 

template<class T>                           // non-const T* RCIPtr<T>::operator->()                  // access; COW 
{ makeCopy(); return counter->pointee; }    // needed 

template<class T>                           // const access; 
const T& RCIPtr<T>::operator*() const       // no COW needed 
{ return *(counter->pointee); } 

template<class T>                           // non-const 
T& RCIPtr<T>::operator*()                   // access; do the 
{ makeCopy(); return *(counter->pointee); } // COW thing 

class Widget { 
public: 
  Widget(int size); 
  Widget(const Widget& rhs); 
  ~Widget(); 
  Widget& operator=(const Widget& rhs); 
  void doThis(); 
  int showThat() const; 
}; 

那么RCWidget将被定义为这样： 
class RCWidget { 
public: 
  RCWidget(int size): value(new Widget(size)) {} 

  void doThis() { 

value->doThis();

 } 

  int showThat() const

 { 

return value->showThat(); 

} 

private: 
  RCIPtr<Widget> value; 
};