《More Effective C++》技术篇——Reference counting（引用计数）

• Reference counting这项技术，允许多个等值对象共享同一实值。此技术的发展有两种动机，第一是为了简化heap object周边的簿记工作。它可以消除“记录对象拥有权”的负荷，因为当对象运用了reference counting技术，它便拥有它自己。一旦不再有任何人使用它，它便会自动销毁自己。reference counting的第二个发展动机则只是为了实现一种常识。如果许多对象有相同的值，将那个值存储多次是件愚蠢的事。最好是让所有等值对象共享一份实值就好。

• 以下是一个包含了Copy-On-Write技术的Reference counting基类，有兴趣建议去看看原书中的文章，作者一步步引导写出这个类，写的很详细，这里因为篇幅原因就不赘述。

  // RCObject.h
  // template class,用来产生smart pointers-to-T objects;T必须继承自RCObject 
  template<class T>
  class RCPtr {
  public:
    RCPtr(T* realPtr = 0);
    RCPtr(const RCPtr& rhs);
    ~RCPtr();
  
    RCPtr& operator=(const RCPtr& rhs);
  
    T* operator->() const;
    T& operator*() const;
  
  private:
    T *pointee;
    void init();
  };
  
  // base class,用于reference-counted objects
  class RCObject {
  public:
    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.cpp
  RCObject::RCObject() : refCount(0), shareable(true) {
  
  }
  
  RCObject::RCObject(const RCObject& rhs) : refCount(0), shareable(true) {
  
  }
  
  RCObject& RCObject::operator=(const RCObject& rhs) {
    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>
  void RCPtr<T>::init () {
    if (pointee == 0)
        return;
    if (pointee->isShareable() == false) {
        pointee = new T(*pointee);
    }
    pointee->addReference();
  }
  
  template<class T>
  RCPtr<T>::RCPtr(T* realPtr) : pointee(realPtr) {
    init();
  }
  
  template<class T>
  RCPtr<T>::RCPtr(const RCPtr& rhs) : pointee(rhs.pointee) {
    init();
  }
  
  template<class T>
  RCPtr<T>::~RCPtr() {
    if (pointee) {
        pointee->removeReference();
    }
  }
  
  template<class T>
  RCPtr<T>& RCPtr<T>::operator=(const RCPtr& rhs){
    if (pointee != rhs.pointee) {
        if (pointee) {
            pointee->removeReference();
        }
        pointee = rhs.pointee;
        init();
    }
    return *this;
  }
  
  template<class T>
  T* RCPtr<T>::operator->() const {
    return pointee;
  }
  
  template<class T>
  T& RCPtr<T>::operator*() const {
    return *pointee;
  }

• 然后，定义一个简单的String类，在String中包含表示其实值的struct StringValue，其中StringValue继承自上面的RCObject，使其拥有引用计数的能力。String代码如下所示。

  // String.h
  // 应用性class，这是应用程序开发人员接触的层面
  #include <string.h>
  #include "RCObject.h"
  class String {
  public:
    String(const char *initValue = "");
  
    const char& operator[] (int index) const;
    char& operator[] (int index);
  
  private:
    // 以下struct用以表现字符串实值
    struct StringValue : public RCObject {
        char *data;
  
        StringValue(const char *initValue);
        StringValue(const StringValue& rhs);
        void init(const char *initValue);
        ~StringValue();
    };
    RCPtr<StringValue> value;
  };
  
  // String.cpp
  void String::StringValue::init(const char *initValue) {
    data = new char[strlen(initValue) + 1];
    strcpy(data, initValue);
  }
  
  String::StringValue::StringValue(const char *initValue) {
    init(initValue);
  }
  
  String::StringValue::StringValue(const StringValue& rhs) {
    init(rhs.data);
  }
  
  String::StringValue::~StringValue() {
    delete [] data;
  }
  
  String::String(const char *initValue) : value(new StringValue(initValue)) {
  
  }
  
  const char& String::operator[](int index) const {
    return value->data[index];
  }
  
  char& String::operator[](int index) {
    if (value->isShared()) {
        value = new StringValue(value->data);
    }
    value->markUnshareable();
    return value->data[index];
  }

• 再来写个main，简单验证下。

  #include <String.h>
  #include <iostream>
  int main()
  {
    String s1 = "hello";
    String s2 = s1;
  
    std::cout << "s1[3] = " << s1[3] << std::endl;
    std::cout << "s2[3] = " << s2[3] << std::endl;
  
    s2[3] = 'x';
  
    std::cout << "s1[3] = " << s1[3] << std::endl;
    std::cout << "s2[3] = " << s2[3] << std::endl;
  }

// 输出
s1[3] = l
s2[3] = l
s1[3] = l
s2[3] = x

• Reference counting是个优化技术，其使用前提是：对象常常共享实值。如果这个假设失败，reference counting反而会赔上更多内存，执行更多代码。从另一个角度看，如果你的对象确实有“共同实值”的倾向，reference counting应可同时节省你的时间和空间。

• 简单说，以下是使用reference counting改善效率的最适当时机：

  • 相对多数的对象共享相对少量的实值（必要）。
  • 对象实值的产生或销毁成本很高，或是它们使用许多内存（非必要）。