智能指针的一种实现

下面是实现智能指针的一种方式，原理就是实现并自动处理引用计数操作的C++模板。

#ifndef SMARTPTR_H
#define SMARTPTR_H

template <class T> class SmartPtr;

////////////////////////////////////////////////////////////////
// IRefCount
// 是引用计数的接口
// 类应该自己实现它
// 或者 SmartPtr 会提供它的 IRefCount 的内部实现
template <class T> class IRefCount
{
friend class SmartPtr<T>;
protected:
virtual void AddRef() = 0;
virtual void Release() = 0;
virtual T * GetPtr() const = 0;
};

////////////////////////////////////////////////////////////////
// IRefCountImpl
// 是 IRefCount 的标准实现
// 要使用的话直接从其派生，比如
// class CMyObject : public IRefCountImpl<CMyObject> { ... }
// 注意：实现 IRefCount 是可选的，但这么做可以减少内存碎片
template <class T> class IRefCountImpl
: public IRefCount<T>
{
private:
int m_Count;
protected:
virtual void AddRef() { m_Count++; }
virtual void Release()
{
assert(m_Count >= 0);
m_Count--;
if(m_Count <= 0)
{
Destroy();
}
}
virtual T * GetPtr() const { return ((T *)this); }
virtual void Destroy()
{
if(GetPtr() != NULL)
delete GetPtr();
}

IRefCountImpl() { m_Count = 0; }
};

////////////////////////////////////////////////////////////////
// SmartPtr
template <class T> class SmartPtr
{
private:
IRefCount<T> * m_RefCount;

////////////////////////////////////////////////////////////
// RefCounter
// 为没有实现 IRefCount 的类提供内部实现
// SmartPtr会自动选择内部实现或者实现 IRefCount 的类
class RefCounter : public IRefCountImpl<T>
{
private:
T * m_Ptr;
protected:
virtual T * GetPtr() const { return m_Ptr; }
virtual void Destroy() { delete this; }
public:
RefCounter (T * ptr) { m_Ptr = ptr; }
virtual ~RefCounter() { IRefCountImpl<T>::Destroy(); }
};

// 如果T没有实现IRefCount，这个方法会被调用
void Assign(void * ptr)
{
if(ptr == NULL)
Assign((IRefCount<T> *)NULL);
else
{
Assign(new RefCounter(static_cast<T *>(ptr)));
}
}

// 如果T实现了 IRefCount，这个方法会代替Assign(void * ptr)
// 这使得一些内存使用优化
void Assign(IRefCount<T> * refcount)
{
if(refcount != NULL)
refcount->AddRef();
IRefCount<T> * oldref = m_RefCount;
m_RefCount = refcount;
if(oldref != NULL)
oldref->Release();
}
public:
SmartPtr() { m_RefCount = NULL; }
SmartPtr(T * ptr) { m_RefCount = NULL; Assign(ptr); }
SmartPtr(const SmartPtr & sp) { m_RefCount = NULL; Assign(sp.m_RefCount); }
virtual ~SmartPtr() { Assign((IRefCount<T> *)NULL); }

T * GetPtr() const { return (m_RefCount == NULL) ? NULL : m_RefCount->GetPtr(); }

// 赋值操作符
SmartPtr& operator = (const SmartPtr & sp)
{
Assign(sp.m_RefCount);
return * this;
}
SmartPtr& operator = (T * ptr)
{
Assign(ptr);
return * this;
}

// T访问和const转换
T * operator ->()
{
assert(GetPtr() != NULL);
return GetPtr();
}
operator T* () const { return GetPtr(); }

// 工具
bool operator !()
{
return GetPtr() == NULL;
}
bool operator ==(const SmartPtr &sp)
{
return GetPtr() == sp.GetPtr();
}
bool operator !=(const SmartPtr &sp)
{
return GetPtr() != sp.GetPtr();
}
};
#endif

下面是使用这个模板的例子：
////////////////////////////////////////////////////////////////
// SmartPtr.cpp
// 如何使用 SmartPtr 的例子
#include <stdio.h>
#include <assert.h>
#include "smartptr.h"

// 定义一个自己的类用来测试
class CMyObject
{
char *name;
public:
CMyObject(char *aname)
{
name = aname;
printf("create %s\n", name);
}
virtual ~CMyObject()
{
printf("delete %s\n", name);
}
void print()
{
printf("print %s\n", name);
}
};

// 测试作为返回值使用
SmartPtr<CMyObject> f1(char *name)
{
return SmartPtr<CMyObject>(new CMyObject(name));
}

// 测试作为参数使用
void f2(CMyObject *o)
{
printf("(print from a function)");
o->print();
}

int main()
{
SmartPtr<CMyObject> ptr1(new CMyObject("1")); // 创建对象“1”
SmartPtr<CMyObject> ptr2 = new CMyObject("2"); // 创建对象“2”

ptr1 = ptr2; // 销毁对象“1”
ptr2 = f1("3"); // 作为返回值使用
ptr2 = NULL; // 销毁对象“3”

/* 错误的用法
CMyObject o1;
ptr1 = &o1; // 不能这么赋值，因为 o1 在栈上

CMyObject * o2 = new CMyObject;
ptr1 = o2;
ptr2 = o2; // 不能这么做，除非CMyObject实现了IRefCount接口
*/
// 甚至可以在整数上用 SmartPtr
SmartPtr<int> a(new int);
SmartPtr<int> b(new int);

*a = 5;
*b = 6;

// 没有内存泄漏！！！
return 0;
}只要SmartPtr对象在作用域内，而且避免那些错误用例，就不会造成内存泄漏。然而，智能指针并不是在每种情况下都能使用的。一个局限就是它不能在多线程的环境下使用。