自身特化的模板类：奇异循环模板

      考虑如下代码：

template<typename T >
class CBase
{
public:
CBase();
~CBase();

static	int*	m_pValue；
}；

class  CDriver	  :  public CBase<CDriver>
{
public:
int	m_key;
}

      上面的代码出现了2个问题：

1.   模板类的T，在整个模板类中并没有用到

2.   派生类以特化的模板类作基类，但是却用自身特化

实际上，这两个问题是为了实现同一个功能：

CBase是个模板类，但其有个static成员函数指针。那么：

class CDriverA    : public CBase<int>

class CDriverB    : public CBase<int>

      如果是这样的代码，CDriverA与CDriverB会从同一个特化模板派生，则CDriverA与CDriverB会共享这个static成员函数指针。若不希望共享，可以采用这样的方式：

class CDriverA    : public CBase<int>

class CDriverB    : public CBase<double>

      这样，CDriverA与CDriverB会从不同特化模板派生，从而CDriverA与CDriverB不共享这个static成员函数指针。

      而实际上，由于T类型并没有在模板中使用，因此编译时这个T是什么并不重要。

于是：

class CDriverA    : public CBase<CDriverA>

class CDriverB    : public CBase<CDriverB>

      这样的代码是合法的，并且其特化模板不同，从而CDriverA与CDriverB不共享这个static成员函数指针。

      这就是用template实现多态的方法。

 

      实际上，在模板类中，只要不涉及T的“实际实现”，即便代码中有T也是可以的。

      不涉及实际实现的情况有以下几个：

1.   T作函数返回值，包括T&与T*

2.   T作函数成员变量，一定要是T*

 

示例代码：定义一个单件父类，从而派生类都是单件：

template<typenameT>classSingleton
{
protected:
Singleton(){};
Singleton(constSingleton&){};
Singleton&operator=(constSingleton&){};
~Singleton();
public:

staticT&GetInstance();

staticT*GetInstancePtr();

private:
staticT*	_instance;
};

template<typenameT>
T*Singleton<T>::_instance=nullptr;

template<typenameT>
Singleton<T>::~Singleton()
{
if(_instance!=nullptr)
{
delete	_instance;
_instance	=	nullptr;
}
}

template<typenameT>
T&Singleton<T>::GetInstance()
{
if(_instance==nullptr)
{
_instance=newT;
}

return*_instance;
}

template<typenameT>
T*Singleton<T>::GetInstancePtr()
{
if(_instance==nullptr)
{
_instance=newT;
}

return_instance;
}

在派生类中：

#include"Singleton.h"

class MyClass : public Singleton<MyClass>
{
public:
intgetNumber() { return 1199;  }
private:
MyClass() {};
//MyClass(constMyClass&) {};
//MyClass& operator =(constMyClass&) {};
~MyClass() {};

friend Singleton<MyClass>;
//friend class auto_ptr<MyClass>;
}

上述代码就是一个奇异循环模板及其派生类。

      注意：

1.   模板类的构造函数，拷贝构造函数，=运算符和析构函数不可以为private，因为private函数不能被派生类访问。考虑到是单件，定义为public并不合适，故定义为protected最合适。

2.   派生类中，由于是循环模板，所以相当于是令基类访问自身，所以要添加：

friend Singleton<MyClass>;

这样，基类就可以访问自身。

3.   派生类无法再派生。

4.   实际上，派生类的构造函数，拷贝构造函数，=运算符和析构函数都可以不再定义。

  

      注意上面的代码仅适用于单线程。若要在多线程下使用，需要在getInstance()函数中引入加锁和双检测机制。