#include <iostream>
 
 
 
//T是任何继承此单例的类名
template <class T>
class Singleton  
{
 
public:  
    //获取类的单例
    static inline T* getinstance();  
    //释放类的单例
    void release();  
protected:
    //作为保护成员的构造函数
    Singleton(void){}
    //作为保护成员的析构函数
    ~Singleton(void){}
    //作为成员变量的静态单例
    static T* _instance;
};  
 
 
//获取类的单例
template <class T>  
inline T* Singleton<T>::getinstance()  
{  
    if(!_instance)  
        _instance=new T();  
    return _instance;  
}  
 
//释放类的单例
template <class T>  
void Singleton<T>::release()  
{  
    if(!_instance)  
        return;  
    delete _instance;
    _instance=0;
}  
 
 
template <class T>
T* Singleton<T>::_instance = 0;
 
 
template <class Pro>    
class FactoryNew : public Singleton<FactoryNew<Pro> >    //继承自单例类Singleton的工厂模式的模板
{
 friend Singleton<FactoryNew<Pro> >;
 public:
 
    Pro *create()
    {
     return new Pro();
    }
 
private:
    FactoryNew(){}
    ~FactoryNew(){} 
}; 
 
 
 
//产品C，由工厂FactoryNew生产
class ProductC
{
public:
    ProductC(){}
    ~ProductC(){}
    void put(){std::cout<<"ProductC is here"<<std::endl;}
};
 
//产品D，由工厂FactoryNew生产
class ProductD
{
public:
    ProductD(){}
    ~ProductD(){}
    void put(){std::cout<<"productD is here"<<std::endl;}
};
 
int main()
{
 
 
    ProductC *proC = FactoryNew<ProductC>::getinstance()->create();
    proC->put();
    delete proC;
    FactoryNew<ProductC>::getinstance()->release();
 
    ProductD *proD = FactoryNew<ProductD>::getinstance()->create();
    proD->put();
    delete proD;
    FactoryNew<ProductD>::getinstance()->release();
    return 0;
}
 
 
 

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