实现“带寿命的Singletons”

鸡生蛋、蛋生鸡问题不必纠结，只需要仔细操控PTrackerArray，看代码

namespace  Private{

class LifetimeTracker{

public:

LifetimeTracker(unsigned int x):longervity__(x){}

vitual ~LifetimeTracker()=0;

friend inline  bool Compare(

unsigned int longevity,const LifetimeTraker *p)

{

return p ->longevity_<longevity;

}

private:

unsigned int longevity_;

}

inline LifetimeTracker::~LifetimeTracker(){}

}

namespace Private{

typedef  LifetimeTracker ** TrackerArray;

extern TrackerArray pTrackerArray;

extern unsigned int elements;

}

template <typename T>void Delete(T *pObj)

{
delete pObj;

}

namespace 

{

template <typename T,typename Destroyer>

class ConcreteLifetimeTracker: public LifetimeTracker

{

public:

ConcreateLifetimeTracker(T* pDynObject,unsigned int longevity,Destroyer destroyer):

LifetimeTracker(longevity),pTracked_(pDynObject),

destroyer_(destroyer)

{}

~ConcreteLifetimeTracker()

{

destroyer_(pTracked_);

}

private:

T *pTracked_;

Destroyer destoryer_;

};

void AtExitFn();

}

template <typename T,typename Destoryer>

void SetLogevity(T *pDynObject ,unsigned int longevity,Destroyer d = Private::Deleter<T>::Delete)

{

TrackerArray pNewArray = static_cast<TrackerArray>(std::realloc(pTrackerArray,sizeof(T)*(elements+1)));

if(!pNewArray)throw std::bad_alloc();

pTrackerArray= pNewArray;

LifetimeTracker *p=new ConcreateLifetimeTracker<T,Destroyer>(pDynObject,longevity,d);

TrackerArray pos = std::upper_bound(pTrackerArray,pTrackerArray+elements,longevity,Compare);

std::copy_backward(pos,pTrackerArray+elements,pTrackerArray+elements+1);

*pos =p;

++elements;

std::atexit(AtExitFn);

}

static void AtExitFn()

{

assert(elements>0&&pTrackerArray !=0);

LifetimeTracker * pTop= pTrackerArray[elemets -1];

pTrackerArray= static_cast<TrackerArray>(std::realloc)(pTrackerArray,sizeof(T)*--elements));

delete pTop;

}

class Log

{

public :

static void Create()

{

pInstance_=new Log;

SetLongevity(*this,longevity_);

}

private:

static const unsigned int longevity_=2;

static Log*pInstance_;

}

多线程处理Singleton

Single& Singleton::Instance()

{

if(!pInstance_)

{

Lock guard(mutex_);

pInstance_=new Singleton;

}

return *pInstance_;

}