前四篇所叙述的每一件事情,都必须动用到我们感兴趣的那个class的源代码.但如果我们想要将reference counting施行于程序库中一个名为Widget的class呢?程序库的行为不是我们可以更改的,所以没办法让Widget继承自RCObject,也就无法对Widget使用smart RCPtrs.
但只要稍微修改设计,我们就可以为任何类型加上reference counting能力.
首先,让我们考虑,如果令Widget继承自RCObject,我们的设计看起来将如何.这种情况下,我们必须增加一个RCWidget class给clients使用,但每件事情都极类似先前的String/StringValue例子:RCWidget扮演String角色,Widget扮演StringValue的角色.整个设计看起来去如下:
现在我们可以将”计算机科学领域中大部分问题得以解决”的原理施展出来.我们可以加上一层间接性.是的,我们增加一个新的CountHolder class,用以持有引用次数,并令CountHolder继承自RCObject.我们也令CountHolder内含一个指针,指向一个Widget.然后将smart RCPtr template以同样聪明的RCIPtr template取代,后者知道CountHolder class 的存在.RCIPtr的”I”意指”indirect”(间接).修改后的设计如下:
就像”StringValue只是实现细节,不需要让String的用户知道”一样,CountHolder也是实现细节,不需要让RCWidget的用户知道.事实上,它是RCIPtr的实现细节,所以我们把它嵌套放进RCIPtr class的内部.RCIPtr的声明如下:
template<typename T>
class RCIPtr
{
public:
RCIPtr(T* realPtr = nullptr);
RCIPtr(const RCIPtr& rhs_);
RCIPtr& operator=(const RCIPtr& rhs_);
~RCIPtr();
public:
const T* operator->() const;
T* operator->();
const T& operator*() const;
T& operator*();
private:
void init();
void makeCopy();
private:
struct CountHolder : public RCObject
{
T* ptr;
~CountHolder()
{
if (ptr != nullptr)
{
delete ptr;
ptr = nullptr;
}
}
};
CountHolder* _counter;
};
RCIPtr和RCPtr之间存在两个差异.第一,”RCPtr对象”之间指向实值,而”RCIPtr对象”通过中介层”CountHolder”对象指向实值;第二,RCIPtr将operator->和operator*重载了,如此一来,只要有non-const access发生于被指物上,copy-on-write(写时进行复制)就会自动执行.
RCIPtr定义如下:
template<typename T>
void RCIPtr<T>::init()
{
if (_counter->isShareable() == false)
{
auto oldptr = _counter->ptr;
_counter = new CountHolder();
_counter->ptr = new T(*oldptr);
}
_counter->addReference();
}
template<typename T>
RCIPtr<T>::RCIPtr(T* realPtr /* = nullptr */)
: _counter(new CountHolder())
{
_counter->ptr = realPtr;
init();
}
template<typename T>
RCIPtr<T>::RCIPtr(const RCIPtr& rhs_)
: _counter(rhs_._counter)
{
init();
}
template<typename T>
RCIPtr<T>& RCIPtr<T>::operator=(const RCIPtr& rhs_)
{
if (_counter ! = rhs_._counter)
{
_counter->removeReference();
_counter = rhs_._counter;
init();
}
return *this;
}
template<typename T>
RCIPtr<T>::~RCIPtr()
{
_counter->removeReference();
}
template<typename T>
const T* RCIPtr<T>::operator->() const
{
return _counter->ptr;
}
template<typename T>
T* RCIPtr<T>::operator->()
{
makeCopy();
return _counter->ptr;
}
template<typename T>
const T& RCIPtr<T>::operator*() const
{
return *(_counter->ptr);
}
template<typename T>
T& RCIPtr<T>::operator*()
{
makeCopy();
return *(_counter->ptr);
}
template<typename T>
void RCIPtr<T>::makeCopy()
{
if (_counter->isShared())
{
auto oldptr = _counter->ptr;
_counter->removeReference();
_counter = new CountHolder();
_counter->ptr = new T(*oldptr);
_counter->addReference();
}
}
有了RCIPtr,RCWidget的实现就很容易了,因为RCWidget的每一个函数都只是通过底层的RCIPtr转调对应的Widget函数.示例如下:
class Widget
{
public:
void doThis()
{
std::cout << "doThis" << std::endl;
}
};
class RCWidget
{
public:
void doThis()
{
_value->doThis();
}
private:
RCIPtr<Widget> _value;
};
对于String类,我们只需要将C++ 简易string类实现(一)参考上述Widget和RCWidget的例子,生成一个对应的RCString就OK了;
小结:通过不断的抽象,最终将引用计数类和用户自定义类完全解耦,而且引用计数类还可以重用于其它用户自定义类,简直 完美!!!
完整代码如下:
class RCObject
{
public:
RCObject();
RCObject(const RCObject& rhs_);
//使RCObject成为抽象基类,但该纯虚函数需要提供
//定义,不然会使被继承的类无法在栈上创建(原因可
//查阅如何仅在堆上或栈上分配内存)
virtual ~RCObject() = 0;
public:
void addReference();
void removeReference();
void markUnshareable();
bool isShareable() const;
bool isShared() const;
private:
RCObject& operator=(const RCObject&) = delete;
private:
int refCount;
bool shareable;
};
template<typename T>
class RCIPtr
{
public:
RCIPtr(T* realPtr = nullptr);
RCIPtr(const RCIPtr& rhs_);
RCIPtr& operator=(const RCIPtr& rhs_);
~RCIPtr();
public:
const T* operator->() const;
T* operator->();
const T& operator*() const;
T& operator*();
private:
void init();
void makeCopy();
private:
struct CountHolder : public RCObject
{
T* ptr;
~CountHolder()
{
if (ptr != nullptr)
{
delete ptr;
ptr = nullptr;
}
}
};
CountHolder* _counter;
};
RCObject::RCObject()
:refCount(0), shareable(true) //refCount初始化为0,其值完全有RCPtr控制
{
}
RCObject::RCObject(const RCObject&)
//调用无参构造函数,注意:该调用仅能在
//初始化成员列表里,如果在函数实现内调用,
//那么仅仅是在栈上生成新的对象,而不是完成
//该对象的成员初始化
:RCObject()
{
std::cout << "RCObject" << std::endl;
}
RCObject::~RCObject()
{
//std::cout << "~RCObject" << std::endl;
}
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<typename T>
void RCIPtr<T>::init()
{
if (_counter->isShareable() == false)
{
auto oldptr = _counter->ptr;
_counter = new CountHolder();
_counter->ptr = new T(*oldptr);
}
_counter->addReference();
}
template<typename T>
RCIPtr<T>::RCIPtr(T* realPtr /* = nullptr */)
: _counter(new CountHolder())
{
_counter->ptr = realPtr;
init();
}
template<typename T>
RCIPtr<T>::RCIPtr(const RCIPtr& rhs_)
: _counter(rhs_._counter)
{
init();
}
template<typename T>
RCIPtr<T>& RCIPtr<T>::operator=(const RCIPtr& rhs_)
{
if (_counter ! = rhs_._counter)
{
_counter->removeReference();
_counter = rhs_._counter;
init();
}
return *this;
}
template<typename T>
RCIPtr<T>::~RCIPtr()
{
_counter->removeReference();
}
template<typename T>
const T* RCIPtr<T>::operator->() const
{
return _counter->ptr;
}
template<typename T>
T* RCIPtr<T>::operator->()
{
makeCopy();
return _counter->ptr;
}
template<typename T>
const T& RCIPtr<T>::operator*() const
{
return *(_counter->ptr);
}
template<typename T>
T& RCIPtr<T>::operator*()
{
makeCopy();
return *(_counter->ptr);
}
template<typename T>
void RCIPtr<T>::makeCopy()
{
if (_counter->isShared())
{
auto oldptr = _counter->ptr;
_counter->removeReference();
_counter = new CountHolder();
_counter->ptr = new T(*oldptr);
_counter->addReference();
}
}