第六章(单件模式)

单件模式比较简单

最常用的写法，子类继承它既可。

template<typename T>
class CSingleton
{
public:
 static T& Instance()
 {
  if (!pInstance_)
  {
   pInstance_ = new T;
  }
  return *pInstance_;
 }
private:
 static T* pInstance_;
protected:
 CSingleton(void)
 {

 }

 CSingleton(const CSingleton&);

 CSingleton& operator = (const CSingleton&);
};

template<typename T>
T* CSingleton<T>::pInstance_ = NULL;

该写法有个问题，instance_是没有析构了，只有退出应用程序，靠操作系统去回收

改进方案：

将instance申明为static，依赖于c++的语言机制去回收

该方案比较简单，但是也有个小问题，如果单件回收有顺序要求，那就不可控了，static对于C++语言要求的析构顺序是：先申明的后析构。

可以使用一种其它方案：在程序退出main中，可以增加一个函数指针，这个函数指针会在exit中进行调用。我们对每个单件申明一个寿命期的变量，寿命期越长的，越晚析构。

其实就是将它保存到vector中，然后依次从vector中取单件对象进行析构，寿命期越晚的，放到越后面

LifetimerTracker.h的实现

#pragma once
#include <stdlib.h>
#include <assert.h>
#include <exception>
#include <algorithm>
//using namespace std;
// 带寿命的singletons
class LifetimeTracker
{
public:
 LifetimeTracker(unsigned int x)
  :longevity_(x)
 {

 }

 virtual ~LifetimeTracker() = 0;

 friend bool MyCompare(const LifetimeTracker* pLeft, const LifetimeTracker* pRight);
private:
 unsigned int longevity_;
};

inline LifetimeTracker::~LifetimeTracker(){}

bool MyCompare(const LifetimeTracker* pLeft, const LifetimeTracker* pRight);

typedef LifetimeTracker** TrackerArray;
extern TrackerArray pTrackerArray;
extern unsigned int elements;
//
template<typename T>
void Delete(T* pObj)
{
 delete pObj;
}
//
template<typename T, typename Destroyer>
class ConcreteLifetimeTracker: public LifetimeTracker
{
public:
 ConcreteLifetimeTracker(T* pDynObject, unsigned int longevity, Destroyer destroyer)
  : LifetimeTracker(longevity),
    pTracked_(pDynObject),
    destroyer_(destroyer)
 {

 }
 ~ConcreteLifetimeTracker()
 {
  destroyer_(pTracked_);
 }
private:
 T* pTracked_;
 Destroyer destroyer_;
};
void AtExitfn();

template<typename T, typename Destroyer>
void SetLongevity(T* pDynObject, unsigned int longevity, Destroyer d = Delete<T>)
{
 TrackerArray pNewArray = static_cast<TrackerArray>(std::realloc(pTrackerArray, sizeof(ConcreteLifetimeTracker<T, Destroyer>) * (elements + 1)));
 if (!pNewArray)
 {
  throw std::bad_alloc();
 }
 pTrackerArray = pNewArray;

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

// 用到了一个排序
 TrackerArray pos = std::upper_bound(pTrackerArray, pTrackerArray + elements, p, MyCompare);

 std::copy_backward(pos, pTrackerArray + elements, pTrackerArray + elements + 1);
 *pos = p;
 ++elements;
 _Atexit(AtExitfn);
}

LifetimerTracker.cpp的实现

#include "StdAfx.h"
#include "LifetimerTracker.h"
TrackerArray pTrackerArray;
unsigned int elements;
void AtExitfn()
{
 assert(elements > 0 && pTrackerArray != 0);
 LifetimeTracker* pTop = pTrackerArray[elements - 1];
 pTrackerArray = static_cast<TrackerArray>(realloc(pTrackerArray, sizeof(TrackerArray) * (--elements)));
 delete pTop;
}
bool MyCompare(const LifetimeTracker* pLeft, const LifetimeTracker* pRight)
{
 return pLeft->longevity_ < pRight->longevity_;
}

简单的测试代码
class CTestSingle
{
public:
 static void Create()
 {
  if (!pInstance_)
  {
   pInstance_ = new CTestSingle;
   SetLongevity<CTestSingle>(pInstance_, 1, Delete<CTestSingle>);
   return;
  }
  CTestSingle* pInstance2 = new CTestSingle;
  SetLongevity<CTestSingle>(pInstance2, 2, Delete<CTestSingle>);
 }
private:
 static CTestSingle* pInstance_;
 int i;
};

CTestSingle* CTestSingle::pInstance_ = NULL;

void Bar()
{

}
void Fun()
{
 _Atexit(Bar);
}

void CTestSingleton::Test()
{
 
 CTestSingle::Create();

 CTestSingle::Create();
 //_Atexit(Fun);
 //SetLongevity((&(CSingleton::Instance())), 1);
}