引用计数在软件开发中是一项非常重用的技术，它可以说是无处不，我们在不知不觉中都在和它打交道，比如 Windows上的COM和Handle， Mac上的ref句柄，脚本语言中的垃圾回收技术。
但是在C++标准库中，却没有内置支持引用计数的技术的支持，下面我们就尝试封装自己的基于引用计数的智能指针。
一般来说，计数方法的实现有2种，内置和外置： 内置指的是对象本身就有计数功能，也就是计数的值变量是对象的成员；外置则是指对象本身不需要支持计数功能，我们是在外部给它加上这个计数能力的。
首先我们来看内置的方法:
封装一个计数功能的对象CRefObject:
class CRefObject
{
public:
CRefObject()
{
m_nRefCount = 0;
}
int GetRefCount() const
{
return m_nRefCount;
}
int AddRefCount()
{
return ++m_nRefCount;
}
int SubRefCount()
{
return --m_nRefCount;
}
void ResetRefCount()
{
m_nRefCount = 0;
}
private:
int m_nRefCount;
};
然后封装我们的智能智能CRefPtr<T>：
//T should inherit from CRefObject
template<typename T>
class CRefPtr
{
public:
T* operator->() const
{
return m_pRawObj;
}
T& operator()() const
{
assert(m_pRawObj != NULL);
return *m_pRawObj;
}
T& operator*() const
{
assert(m_pRawObj != NULL);
return *m_pRawObj;
}
T* GetPtr() const
{
return m_pRawObj;
}
bool IsNull() const
{
return m_pRawObj == NULL;
}
explicit CRefPtr(T* p = NULL)
{
m_pRawObj = p;
if(p != NULL)
{
p->AddRefCount();
}
}
CRefPtr(const CRefPtr& ref)
{
m_pRawObj = ref.m_pRawObj;
if(m_pRawObj != NULL)
{
m_pRawObj->AddRefCount();
}
}
~CRefPtr()
{
if(m_pRawObj != NULL && m_pRawObj->SubRefCount() == 0)
{
delete m_pRawObj;
}
}
CRefPtr& operator = (const CRefPtr& ref)
{
if(this != &ref)
{
if(m_pRawObj != NULL
&& m_pRawObj->SubRefCount() == 0)
{
delete m_pRawObj;
}
m_pRawObj = ref.m_pRawObj;
if(m_pRawObj != NULL)
{
m_pRawObj->AddRefCount();
}
}
return *this;
}
bool operator == (const CRefPtr& ref) const
{
return m_pRawObj == ref.m_pRawObj;
}
private:
T* m_pRawObj;
};
通过上面的代码可以看到，我们要求要支持引用计数的对象都要从CRefObject继承，也就是给这个对象内置计数功能。
然后我们就可以这样使用了：
#include <iostream>
using namespace std;
#include "RefPtr.h"
class CTest: public CRefObject
{
public:
CTest(int n)
:m_n(n)
{
cout << "CTest(" << m_n << ") \n";
}
~CTest()
{
cout << "~CTest(" << m_n << ") \n";
}
void Print()
{
cout << m_n << "\n";
}
int m_n;
};
int main(int argc, char* argv[])
{
{
CRefPtr<CTest> p1(new CTest(1));
CRefPtr<CTest> p2(new CTest(2));
p1->Print();
p1 = p2;
}
system("pause");
return 0;
}
接下来我们尝试实现据通过外置方法实现引用计数的智能指针CRefIPtr<T>, 代码如下：
template<typename T>
class CRefIPtr
{
public:
T* operator->() const
{
return GetObjectPtr();
}
T& operator()() const
{
return GetObject();
}
T& operator*() const
{
return GetObject();
}
T* GetPtr() const
{
return GetObjectPtr();
}
bool IsNull() const
{
return (m_pHolder != NULL
&& m_pHolder->m_pRawObj != NULL);
}
explicit CRefIPtr(T* p = NULL)
{
m_pHolder = new CRefHolder;
if(m_pHolder != NULL)
{
m_pHolder->m_pRawObj = p;
m_pHolder->AddRefCount();
}
}
CRefIPtr(const CRefIPtr& ref)
{
m_pHolder = ref.m_pHolder;
if(m_pHolder != NULL)
{
m_pHolder->AddRefCount();
}
}
~CRefIPtr()
{
if(m_pHolder != NULL
&& m_pHolder->SubRefCount() == 0)
{
delete m_pHolder;
}
}
CRefIPtr& operator = (const CRefIPtr& ref)
{
if(this != &ref
&& m_pHolder != ref.m_pHolder)
{
if(m_pHolder != NULL
&& m_pHolder->SubRefCount() == 0)
{
delete m_pHolder;
}
m_pHolder = ref.m_pHolder;
if(m_pHolder != NULL)
{
m_pHolder->AddRefCount();
}
}
return *this;
}
bool operator == (const CRefIPtr& ref) const
{
return m_pHolder == ref.m_pHolder;
}
protected:
T& GetObject() const
{
assert(m_pHolder != NULL
&& m_pHolder->m_pRawObj != NULL);
return *(m_pHolder->m_pRawObj);
}
T* GetObjectPtr() const
{
if(m_pHolder != NULL)
{
return m_pHolder->m_pRawObj;
}
else
{
return NULL;
}
}
class CRefHolder: public CRefObject
{
public:
CRefHolder()
{
m_pRawObj = NULL;
}
~CRefHolder()
{
delete m_pRawObj;
}
T* m_pRawObj;
};
private:
CRefHolder* m_pHolder;
};
可以看到在外置的方法中我们内部封装了一个具有计数功能的
CRefHolder， 通过它实现我们的计数功能， 具体用法和上面CRefPtr类似，只不过CRefIPtr不再强制要求对象从CRefObject继承。
下面我们来讨论这2种方法的优缺点：
（1）从性能上来说，肯定内置的高，因为它不用通过新建内部Holder对象。
(2) 从易用性上来说， 外置的更方便，因为它不强制要求对象从CRefObject继承。
(3) 从使用范围上说, 外置的更广阔, 因为外置的方法支持C++ 内置类型也很方便， 比如CRefIPtr<int> p(new int(1)), 内置的却做不到。
但是外置的比内置在使用不当的情况下，有时更容易出错，比如下面的代码：
int main(int argc, char* argv[])
{
{
CRefPtr<CTest> p1(new CTest(1));
CTest* pRaw = p1.GetPtr();
CRefPtr<CTest> p2(pRaw);
}
system("pause");
return 0;
}
用
CRefPtr运行正常，但是改成CRefIPtr时，却会Crash。
究其原因是在内置情况下我们可以知道原始对象内部的计数值，但是外置情况下就无能为力了。
当然上面的用法本身就是不规范的，就像你这样用：
int main(int argc, char* argv[])
{
{
CTest t(1);
CRefPtr<CTest> p2(&t);
}
system("pause");
return 0;
}
上面代码，无论用内置还是外置，都会Crash。
当然，我们上面的2种引用计数智能指针在实现上都没有考虑多线程的情况，多线程情况只要给CRefObject加锁就可以了。
基于引用计数智能指针还有一个致命的缺点就是循环引用，会造成对象没法自动释放，这种情况下需要我们在需要释放对象时手动将指针值设成NULL。
总之，如果我们要在正式项目中使用这种方式的智能指针，使用者要对它的内部机制有深入的理解，同时建议不要同时混用智能指针和原始指针，另外建议只在模块内部使用，而不要跨模块传递智能指针。
上面是我对引用计数智能指针的一些理解和看法，如果有不正确的地方，欢迎指正。
posted on 2012-05-05 17:04
Richard Wei 阅读(4916)
评论(4) 编辑 收藏 引用 所属分类:
C++