带引用计数的智能指针（模板类）实现的3种方法

转载自：http://www.cppblog.com/playerken/archive/2011/08/10/152990.html

1. 非侵入式：static map<unsigned int, int>，key是对象地址，value是counter。

2. 非侵入式：构造函数new一个int作为counter，拷贝构造函数和赋值操作符中传递该counter。

3. 侵入式：定义一个Count基类自带counter，所有对象继承与Count基类，counter在对象中。

方法2无法重载 operator = (T *t)，因为无法从参数中获得t的counter信息。

Code1: 用static map作为counter

#include <stdio.h>
#include <map>

using namespace std;

class A
{
public:
A()
{
printf("\nA Construct\n");
}

~A()
{
printf("\nA Destruct\n");
}
};

class B
{
public:
B()
{
printf("\nB Construct\n");
}

~B()
{
printf("\nB Destruct\n");
}
};

template <typename T>
class SmartPtr
{
public:
SmartPtr(T *t)
{
Pointee = t;

map<unsigned int, int>::iterator it = CountMap.find((unsigned int)t);
if(it != CountMap.end())
++(it->second);
else
CountMap[(unsigned int)Pointee] = 1;
}

SmartPtr(const SmartPtr &sp)
{
Pointee = sp.Pointee;

map<unsigned int, int>::iterator it = CountMap.find((unsigned int)Pointee);
if(it != CountMap.end())
++(it->second);
else
CountMap[(unsigned int)Pointee] = 1;
}

SmartPtr& operator = (const SmartPtr &sp)
{
if(NULL != Pointee)
{
--CountMap[(unsigned int)Pointee];
if(CountMap[(unsigned int)Pointee] == 0)
{
CountMap.erase((unsigned int)Pointee);
delete Pointee;
Pointee = NULL;
}
}

Pointee = sp.Pointee;

map<unsigned int, int>::iterator it = CountMap.find((unsigned int)Pointee);
if(it != CountMap.end())
++(it->second);
else
CountMap[(unsigned int)Pointee] = 1;

return *this;
}

SmartPtr& operator = (T *t)
{
if(NULL != Pointee)
{
--CountMap[(unsigned int)Pointee];
if(CountMap[(unsigned int)Pointee] == 0)
{
CountMap.erase((unsigned int)Pointee);
delete Pointee;
Pointee = NULL;
}
}

Pointee = t;

map<unsigned int, int>::iterator it = CountMap.find((unsigned int)Pointee);
if(it != CountMap.end())
++(it->second);
else
CountMap[(unsigned int)Pointee] = 1;

return *this;
}

~SmartPtr()
{
if(NULL != Pointee)
{
--CountMap[(unsigned int)Pointee];
if(CountMap[(unsigned int)Pointee] == 0)
{
CountMap.erase((unsigned int)Pointee);
delete Pointee;
Pointee = NULL;
}
}
}
private:
T *Pointee;
static map<unsigned int, int> CountMap;
SmartPtr();
};

template <typename T>
map<unsigned int, int> SmartPtr<T>::CountMap;

int main()
{
A *objA1 = new A();
A *objA2 = new A();
A *objA3 = new A();
B *objB1 = new B();
B *objB2 = new B();
B *objB3 = new B();

SmartPtr<A> sPtrA1(objA1);
SmartPtr<A> sPtrA2(objA2);
sPtrA1 = sPtrA2;
sPtrA1 = objA3;
sPtrA2 = objA3;

SmartPtr<B> sPtrB1(objB1);
SmartPtr<B> sPtrB2(objB2);
sPtrB1 = sPtrB2;
sPtrB1 = objB3;
sPtrB2 = objB3;
return 0;
}

Code2: 用new int作为counter

#include <stdio.h>

class A
{
public:
A()
{
printf("\nA Construct\n");
}

~A()
{
printf("\nA Destruct\n");
}
};

class B
{
public:
B()
{
printf("\nB Construct\n");
}

~B()
{
printf("\nB Destruct\n");
}
};

template <typename T>
class SmartPtr
{
public:
SmartPtr(T *t)
{
Pointee = t;

Count = new int(0);
++(*Count);
}

SmartPtr(const SmartPtr &sp)
{
Pointee = sp.Pointee;
Count = sp.Count;
++(*Count);
}

SmartPtr& operator = (const SmartPtr &sp)
{
if(NULL != Pointee)
--(*Count);
if(*Count == 0)
delete Pointee;

Pointee = sp.Pointee;
Count = sp.Count;
++(*Count);

return *this;
}

// Cannot work well.
// Should not public this method.
SmartPtr& operator = (T *t)
{
if(NULL != Pointee)
--(*Count);
if(*Count == 0)
{
delete Pointee;
delete Count;
}
Pointee = t;
// Cannot get the counter on t.
Count = new int(0);
++(*Count);

return *this;
}

~SmartPtr()
{
if(NULL != Pointee)
--(*Count);
if(*Count == 0)
{
delete Pointee;
Pointee = NULL;
}
delete Count;
}
private:
T *Pointee;
int *Count;
SmartPtr();
};

int main()
{
A *obj1 = new A();
A *obj2 = new A();
A *obj3 = new A();
B *objB1 = new B();
B *objB2 = new B();
B *objB3 = new B();

SmartPtr<A> sPtr1(obj1);
SmartPtr<A> sPtr2(obj2);
sPtr1 = sPtr2;
sPtr1 = obj3;
// Comment out since SmartPtr cannot get the existing counter on obj3.
//sPtr2 = obj3;

SmartPtr<B> sPtrB1(objB1);
SmartPtr<B> sPtrB2(objB2);
sPtrB1 = sPtrB2;
sPtrB1 = objB3;
// Comment out since SmartPtr cannot get the existing counter on objB3.
//sPtrB2 = objB3;
return 0;
}

Code3: 对象继承与Count基类，counter在对象内

#include <stdio.h>

class ReferenceCount
{
public:
virtual ~ReferenceCount(){};
int Count;
protected:
ReferenceCount():Count(0){};
};

class Intrusive: public ReferenceCount
{
public:
Intrusive()
{
printf("\nInstrusive Construct\n");
}

~Intrusive()
{
printf("\nInstrusive Destruct\n");
}
};

class B: public ReferenceCount
{
public:
B()
{
printf("\nB Construct\n");
}

~B()
{
printf("\nB Destruct\n");
}
};

template <typename T>
class SmartPtrIntrusive
{
public:
SmartPtrIntrusive(T *t)
{
Pointee = t;
++Pointee->Count;
}

SmartPtrIntrusive(const SmartPtrIntrusive &sp)
{
Pointee = sp.Pointee;
++Pointee->Count;
}

SmartPtrIntrusive& operator = (const SmartPtrIntrusive &sp)
{
if(NULL != Pointee)
--Pointee->Count;
if(Pointee->Count == 0)
{
delete Pointee;
Pointee = NULL;
}

Pointee = sp.Pointee;
++Pointee->Count;

return *this;
}

SmartPtrIntrusive& operator = (T *t)
{
if(NULL != Pointee)
--Pointee->Count;
if(Pointee->Count == 0)
{
delete Pointee;
Pointee = NULL;
}

Pointee = t;
++Pointee->Count;

return *this;
}

~SmartPtrIntrusive()
{
if(NULL != Pointee)
--Pointee->Count;
if(Pointee->Count == 0)
{
delete Pointee;
Pointee = NULL;
}
}
private:
T *Pointee;
SmartPtrIntrusive();
};

int main()
{
Intrusive *obj1 = new Intrusive();
Intrusive *obj2 = new Intrusive();
Intrusive *obj3 = new Intrusive();
B *objB1 = new B();
B *objB2 = new B();
B *objB3 = new B();
SmartPtrIntrusive<Intrusive> sPtr1(obj1);
SmartPtrIntrusive<Intrusive> sPtr2(obj2);
sPtr1 = sPtr2;
sPtr1 = obj3;
sPtr2 = obj3;

SmartPtrIntrusive<B> sPtrB1(objB1);
SmartPtrIntrusive<B> sPtrB2(objB2);
sPtrB1 = sPtrB2;
sPtrB1 = objB3;
sPtrB2 = objB3;
return 0;
}