C++引用计数（reference counting）技术简介（2）
1.一个引用计数（Reference-Counting）基类
Reference-counting可用于字符串以外的场合，任何class如果其不同的对象可能拥有相同的值，都适用此技术。但是如果重写class以便适用reference counting可能需要大量的工作。
我们可以设计一个引用计数基类RCObject，供想拥有引用计数的类继承。RCObject将“引用计数器”本身以及用以增减引用数值的函数封装起来。此外，还包括销毁对象值的函数，设置不可共享标的函数，返回共享标志的函数，查询是否在被共享的函数，查询引用计数的数目。没有必要提供一个设定共享标志位true的成员函数，因为所有的对象值在默认情况下都是可共享的。这里设定一旦某个对象被贴上”不可共享”标签，其永远都将是不可共享。
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;
} 注意：
（1）RCObject的赋值运算符opeator=()什么也没有做，实际上可共享的实值实际不太可能被赋值。例如在自定义String类中，实值StringValue并不不会被赋值，而是String对象的赋值。
（2）RCObject::removeReference的责任不只在于将对象的refCount递减，而有当引用计数refCount为0时，销毁实值对象。使用delete this来销毁实值对象，那就要求*this是heap对象。
2.基于引用计数基类的String
基于引用计数的基类String设计如下：
class String{
private:
Struct StringValue:public RCObject{
char* data;
StringValue(const char* initValue);
~StringValue();
};
StringValue* value;
public:
String(const char* initValue="");//constructor
String(const String& rhs);//copy constructor
String& operator=(const String& rhs); //assignment operator
~String(); //destructor
};
//StringValue的构造函数
String::StringValue::StringValue(const char* initValue):refCount(1){
data=new char[strlen(initValue)+1];
strcpy(data,initValue);
}
//StringValue的析构函数
String::StringValue::~StringValue(){
delete[] data;
}这一版本的StringValue几乎与前一版本完全相同，唯一的改变是StringValue的member functions不再处理引用计数refCount字段，改由RCObject掌握。
3.自动操作引用次数（Reference Count）
RCObject class存放了引用次数，也给出了操作引用次数的member fucntions，这些函数的调用动作还是得用户手动写到其他的class内，并且通过String constructor和String assignment operator调用StringValue对象所提供的addReference和removeReference。这里，我们使用可复用的类，不必让用户类去操作引用次数。这里可复用的类产生的对象我们呢称之为smart pointer。
下面使用template来实现smart pointers，指向reference-counted实值对象。
//智能指针模板类，用来自动执行引用计数实值类成员的操控动作
template<typename 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; //dumb pointer
void init(); //共同的初始化操作
};
//共同的初始化操作
template<typename T>
void RCPtr<T>::init(){
if (pointee == 0) return;
if (pointee->isShareable() == false) {
pointee = new T(*pointee);
}
pointee->addReference();
}
//构造函数
template<typename T>
RCPtr<T>::RCPtr(T* realPtr) :pointee(realPtr){
init();
}
//拷贝构造函数
template<typename T>
RCPtr<T>::RCPtr(const RCPtr& rhs) : pointee(rhs.pointee){
init();
}
//析构函数
template<typename T>
RCPtr<T>::~RCPtr(){
if (pointee)
pointee->removeReference();
}
//赋值运算符
template<typename T>
RCPtr<T>& RCPtr<T>::operator=(const RCPtr& rhs){
if (pointee != rhs.pointee) {
if (pointee)
pointee->removeReference();
pointee = rhs.pointee;
init();
}
return *this;
}
//重载成员选取运算符 ->
template<typename T>
T* RCPtr<T>::operator->() const { return pointee; }
//重载解引用运算符*
template<typename T>
T& RCPtr<T>::operator*() const { return *pointee; } 4.最终String
在上面的基础之上，我们利用具有服用性质的RCObject和RCPtr classes为基础，建造一个reference-counted String class。每一个具有引用计数功能的String对象均以此数据结构实现出来：
最终的String描述如下：
class String {
public:
String(const char *value = "");//构造函数
const char& operator[](int index) const;//重载[]运算符，针对const Strings
char& operator[](int index);//重载[]运算符，针对non-const Strings
private:
struct StringValue : public RCObject {//继承自引用计数基类
char *data;
StringValue(const char *initValue);//构造函数
StringValue(const StringValue& rhs);//拷贝赋值运算符
void init(const char *initValue);
~StringValue();//析构函数
};
RCPtr<StringValue> value;//智能指针对象
};
//String::StringValue实现代码
void String::StringValue::init(const char *initValue){
data = new char[strlen(initValue) + 1];
strcpy(data, initValue);
}
//StringValue类的构造函数
String::StringValue::StringValue(const char *initValue){
init(initValue);
}
//StringValue类的拷贝赋值运算符
String::StringValue::StringValue(const StringValue& rhs){
init(rhs.data);
}
//StringValue类的析构函数
String::StringValue::~StringValue(){
delete[] data;
}
//String实现代码
//String类的构造函数
String::String(const char *initValue): value(new StringValue(initValue)) {}
//重载[]运算符，针对const Strings
const char& String::operator[](int index) const{
return value->data[index];
}
//重载[]运算符，针对non-const Strings
char& String::operator[](int index){
if (value->isShared()) {
value = new StringValue(value->data);
}
value->markUnshareable();
return value->data[index];
} 注意，这里使用智能指针对象的String并不需要显示定义copy constructor和assignment operator，因为这些编译器为默认生成，并且会自动调用String内RCPtr member的copy constructor和assignment operator，而后者又会自动执行对StringValue对象的所有处理，包括引用次数。
[1]More Effective C++.Scott Meyers著，侯捷译.P183-213.
[2]http://blog.csdn.net/ruan875417/article/details/48267527.