用模板写一个单利类，怎么写？
如题，，，，，，， 啊啊啊
[解决办法]
OK, I spend a few minutes and wrote this one, is it what you want?
template<typename T>
class SingleTon
{
public:
static SingleTon& Instance()
{
return instance_;
}
void print()
{
cout << " hi hi hi " << endl;
}
private:
SingleTon(){}
~SingleTon(){}
static SingleTon instance_;
};
struct Foo
{
};
SingleTon<Foo> SingleTon<Foo>::instance_;
int main()
{
SingleTon<Foo>& s = SingleTon<Foo>::Instance();
s.print();
return 0;
}
template<typename T>
class Singleton
{
public:
static T* Instance()
{
if(NULL == m_pInstance)
return new T();
return m_pInstance;
}
static void Release()
{
if(m_pInstance != NULL)
{
delete m_pInstance;
m_pInstance = NULL;
}
}
static T* m_pInstance;
protected:
Singleton(){}
~Singleton(){}
};
template<class T> T* Singleton<T>::m_pInstance = NULL;
//使用
class A : public Singleton<A>
{
protected:
friend class Singleton<A>;
A(){}
public:
~A(){}
void print()
{
cout << " hi hi hi " << endl;
}
};
int main()
{
A::Instance()->print();
A::Release();
return 0;
}
#define SINGLETON(CT) /*单例模式*/\
private:\
CT ( void );\
CT ( const CT & );/*disallowed*/\
CT & operator= ( CT & );/*disallowed*/\
static CT *m_Instance; \
public:\
static CT *GetInstance ( void ) /*返回类的唯一实例的指针, 初次调用时调用构造函数*/\
{\
if ( m_Instance == NULL )\
m_Instance = new CT;\
return m_Instance;\
}
#ifndef _SINGLETON_H_
#define _SINGLETON_H_
// Singleton 模式
#include "sync.h"
// #define NULL ((void *)0)
template <typename T>
class Singleton
{
private:
Singleton() {}; // ctor hidden
Singleton (Singleton const&);// copy ctor hidden
Singleton & operator=( Singleton const&);// assign op. hidden
~ Singleton (); // dtor hidden
static T* instance_;
public:
static T* Instance()
{
// double-check locking
if (instance_ == NULL)
{
static CSync sync;
sync.Lock();
if (instance_ == NULL)
instance_ = new T();
sync.Unlock();
}
return instance_;
}
};
template <typename T>
T* Singleton<T>::instance_ = NULL;
#endif // _SINGLETON_H_
/*comments are welcome via email: bruceadi@hotmail.com*/
#include <cassert>
template< typename T>
T& instance()
{
static T t;
return t;
}
//or
template<typename T>
class SingleonHolder
{
public:
static T& instance()
{
static SingleonHolder<T> inst;
return inst.t;;
}
private:
SingleonHolder(){}
~SingleonHolder(){}
SingleonHolder(SingleonHolder const&); //forbidden copy construct
SingleonHolder& operator= (SingleonHolder const&); //forbidden copy construct assignment
T t;
};
//or
template <typename Derived>
class SingleonBase
{
public:
static Derived& instance()
{
static Derived inst;
return inst;
}
protected:
SingleonBase() {}
SingleonBase(SingleonBase const&); //forbidden copy construct
SingleonBase& operator = (SingleonBase const&); //forbidden copy construct assignment
~SingleonBase(){}
};
struct Widget : public SingleonBase<Widget>
{
};
int main(int, char* args[])
{
assert(&instance<int>() == &instance<int>());
assert(&SingleonHolder<int>::instance() == &SingleonHolder<int>::instance());
assert(&Widget::instance() == &Widget::instance());
return 0;
}
