C++引用计数（reference counting）技术简介（3）

1.将Reference Counting加到既有的Class

要想将引用计数施加到现有的实值对象Widget上，按照前面讨论的，都需要修改Winget类的源代码。但是，有时程序库的内容不是我们呢可以修改的，又该如何做呢？

如果令Widget继承自RCObject，我们必须增加一个RCWidget class给用户使用，这很像之前关于String/StringValue的讨论。RCWidget扮演String的角色，Widget扮演StringValue的角色。整个设计结构如下：



但这么做的话就需要修改Widget使其继承自RCObject。我们可以增加一个新的CountHolder class，用以持有引用计数，并令CountHolder继承自RCObject。我们也令CountHolder内含一个指针，指向一个Widget。然后将smart RCPtr template以同样聪明的RCIPtr template取代，RCIPtr template包含CountHolder的一个指针。RCIPtr 的”I”意指”indirect”间接。修改后的设计如下：



引用计数基类RCObject基本不变，其源码如下：

//引用计数基类
class RCObject{
public:
RCObject();//构造函数
RCObject(const RCObject& rhs);//拷贝构造函数
RCObject& operator=(const RCObject& rhs);//拷贝赋值运算符
virtual ~RCObject() = 0;//析构函数

void addReference();//增加引用计数
void removeReference();//减少引用计数,如果变为0，销毁对象
void markUnshareable();//将可共享标志设为false
bool isShareable() const;//判断其值是否可共享
bool isShared() const;//判断其值是否正在被共享
int getRefCount();//返回引用计数
private:
int refCount;//保存引用计数
bool shareable;//保存其值是否可共享的状态
};

//构造函数，这里refCount设为0，让对象创建者自行或将refCoun设为1
RCObject::RCObject(void) :refCount(0), shareable(true){}

//拷贝构造函数，总是将refCount设为0，因为正在产生一个新对象，只被创建者引用
RCObject::RCObject(const RCObject&) : refCount(0), shareable(true){}

//拷贝赋值运算符，这里只返回*this,因为左右两方RCObject对象的外围对象个数不受影响
RCObject& RCObject::operator=(const RCObject& rhs){
return *this;
}

//析构函数
RCObject::~RCObject(){}

//增加引用计数
void RCObject::addReference(){
++refCount;
}

//减少引用计数,如果变为0，销毁对象
void RCObject::removeReference(){
if (--refCount == 0)
delete this;
}

//将追踪其值是否可共享的成员设为false
void RCObject::markUnshareable(){
shareable = false;
}

//判断其值是否可共享
bool RCObject::isShareable() const{
return shareable;
}

//判断其值是否正在被共享
bool RCObject::isShared() const{
return refCount>1;
}

//返回引用计数
int RCObject::getRefCount(){
return refCount;
}

template RCIPtr的实现如下：

//智能指针模板类，用来自动执行引用计数类成员的操控动作
template<typename T>
class RCIPtr{
public:
RCIPtr(T* realPtr = 0);//构造函数
RCIPtr(const RCIPtr& rhs);//拷贝构造函数
~RCIPtr();//析构函数
RCIPtr& operator=(const RCIPtr& rhs);//拷贝赋值运算符
const T* operator->() const;//重载->运算符
T* operator->();//重载->运算符
const T& operator*() const;//重载*运算符
T& operator*();//重载*运算符
private:
struct CountHolder :public RCObject{
~CountHolder() { delete pointee; }
T* pointee;
};
CountHolder* counter;
void init();//初始化操作
void makeCopy();//copy-on-write中的copy部分
};
//共同的初始化操作
template <typename T>
void RCIPtr<T>::init(){
if (counter->isShareable() == false){
T* oldValue = counter->pointee;
counter = new CountHolder;
counter->pointee = new T(*oldValue);
}
counter->addReference();
}
//构造函数
template <typename T>
RCIPtr<T>::RCIPtr(T* realPtr) :counter(new CountHolder){
counter->pointee = realPtr;
init();
}
//拷贝构造函数
template <typename T>
RCIPtr<T>::RCIPtr(const RCIPtr& rhs) :counter(rhs.counter){
init();
}
//析构函数
template <typename T>
RCIPtr<T>::~RCIPtr(){
counter->removeReference();
}
//拷贝赋值运算符
template <typename T>
RCIPtr<T>& RCIPtr<T>::operator=(const RCIPtr& rhs){
if (counter != rhs.counter){
counter->removeReference();
counter = rhs.counter;
init();
}
return *this;
}
//重载->运算符，const版本
template<typename T>
const T* RCIPtr<T>::operator->() const { return counter->pointee; }
//重载*运算符，non-const版本
template<typename T>
const T& RCIPtr<T>::operator*() const { return *(counter->pointee); }
//copy-on-write中的copy部分
template <typename T>
void RCIPtr<T>::makeCopy(){
if (counter->isShared()){
T* oldValue = counter->pointee;
counter->removeReference();
counter = new CountHolder;
counter->pointee = new T(*oldValue);
counter->addReference();
}
}
//重载->运算符，non-const版本
template <typename T>
T* RCIPtr<T>::operator->(){
makeCopy();
return counter->pointee;
}
//重载*运算符，non-const版本
template <typename T>
T& RCIPtr<T>::operator*(){
makeCopy();
return *(counter->pointee);
}

RCIPtr和RCPtr之间有两个差异，一个是RCPtr对象直接指向实值，而RCIPtr对象通过中介层“CountHolder对象”指向实值。第二是RCIPtr将operator->和operator*重载了，如此一来只要有non-const access发生在被指物身上，copy-on-write（写时复制）就会被执行。

有了RCIPtr，RCWidget的实现就很容易，因为RCWidget的每一个函数都只是通过底层的RCIPtr转调用对应的Widget函数。Widget和RCWidget的示例代码如下。

class Widget{
public:
Widget(int s = 0) :size(s){}
Widget(const Widget& rhs) { size = rhs.size; }
~Widget(void) {}

Widget& operator=(const Widget& rhs){
if (this == &rhs)
return *this;
this->size = rhs.size;
return *this;
}
void doThis() { std::cout << "doThis()" << std::endl; }
int showThat() const {
std::cout << "showThat()" << std::endl;
return size;
}
private:
int size;
};

class RCWidget{
public:
RCWidget(int size = 0) :value(new Widget(size)){}
~RCWidget() {}

void doThis() { value->doThis(); }
int showThat() const { return value->showThat(); }
private:
RCIPtr<Widget> value;
};

注意，RCWidget没有申明拷贝构造函数，也没有赋值运算符和析构函数，就像先前的String class一样，不再需要撰写这些函数了，因为编译器生成的默认版本做了正确的事情。

2.总结

引用计数的实现需要成本。每一个拥有计数能力的实值都有一个引用计数器，而大部分操作都需要能够以某种方式检查或处理这个引用计数器，因此对象的实值需要更多内存。而且引用计数的底层源代码比没有引用计数的复杂的多。

引用计数是个优化计数，其适用前提是对象常常共享实值。使用引用计数改善效率的时机有以下两个：

第一，相对多数的对象共享相对少量的实值；

第二，对象实值的产生或销毁成本很高，或是它们使用许多内存。

参考文献

[1]More Effective C++.Scott Meyers著，侯捷译.P183-213.

[2]http://blog.csdn.net/ruan875417/article/details/48267527.