#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;
}