Singleton模式的C++实现研究（示例代码）
|
|
|
|
[附件一：演示程序代码清单]
/*//////////////////////////////////////////////////////////////////
作者：张友邦
时间：2002年10月9日
描述：实现Singleton
/*//////////////////////////////////////////////////////////////////
#include <iostream.h>
#include <tchar.h>
////////////////////////////////////////////////////////////////////
//第一种实现(使用模板函数)
class MySingleton1
{
private:
MySingleton1(){ cout << _T("Construct MySingleton1") << endl; }
MySingleton1 & operator =(const MySingleton1&){}
template <typename T>
friend T& GetInstanceRef();
public:
~MySingleton1(){ cout << _T("Destroy MySingleton1") << endl; }
public:
void DoSomething(){ cout << _T("Do something here in MySingleton1") << endl; }
};
template <typename T>
T& GetInstanceRef()
{
static T _instance;
return _instance;
}
template <typename T>
T* GetInstancePtr()
{
return &GetInstanceRef<T>();
}
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//第二种实现(使用模板类)
template <typename T>
class SingletonWraper
{
public:
static T& GetInstanceRef()
{
static T _instance;
return _instance;
}
static const T& GetInstanceConst()
{
return GetInstanceRef();
}
static T* GetInstancePtr()
{
return &GetInstanceRef();
}
};
#define DEFINE_SINGLETON(ClassName); \
public: \
friend class SingletonWraper<ClassName>; \
typedef class SingletonWraper<ClassName> SingletonWraper; \
typedef SingletonWraper SingletonInterface; \
private: \
const ClassName& operator=(const ClassName&) \
{ \
return SingletonInterface::GetInstanceRef(); \
} \
ClassName(const ClassName&); \
private: \
static void operator delete(void *p, size_t n) \
{ \
throw -1; \
}//End of define DECLARE_SINGLETON(ClassName);
class MySingleton2
{
DEFINE_SINGLETON(MySingleton2);
private:
MySingleton2(){ cout << _T("Construct MySingleton2") << endl; }
public:
~MySingleton2(){ cout << _T("Destroy MySingleton2") << endl; }
public:
void DoSomething(){ cout << _T("Do something here in MySingleton2") << " " << endl; }
};
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//第三种实现(由类自身实现，自动销毁对象，相比之下，它更简单)
#define DECLARE_SINGLETON(ClassName); \
public: \
static ClassName& GetInstanceRef() \
{ \
static ClassName _instance; \
return _instance; \
} \
static const ClassName& GetInstanceConst() \
{ \
return GetInstanceRef(); \
} \
static ClassName* GetInstancePtr() \
{ \
return &GetInstanceRef(); \
} \
const ClassName& operator=(const ClassName&) \
{ \
return GetInstanceRef(); \
} \
private: \
ClassName(const ClassName&); \
static void operator delete(void *p, size_t n) \
{ \
throw -1; \
}//End of define DECLARE_SINGLETON(ClassName);
class MySingleton3
{
DECLARE_SINGLETON(MySingleton3);
private:
MySingleton3(){ cout << _T("Construct MySingleton3") << endl; ID = 0; }
public:
int ID;
~MySingleton3(){ cout << _T("Destroy MySingleton3") << endl; }
void DoSomething(){ cout << _T("Do something here in MySingleton3, ID = ") << ID << endl; }
};
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//第四种实现(《Design Patterns》里的，做了一些修改)
//(由类自身实现，手动与自动销毁对象)
#define ALLOW_SINGLETON(ClassName); \
private: \
static ClassName* _instance; \
\
public: \
static ClassName& GetInstanceRef() \
{ \
if (_instance == 0) \
_instance = new ClassName; \
return *_instance; \
} \
static ClassName* GetInstancePtr() \
{ \
return &GetInstanceRef(); \
} \
static ReleaseInstance() \
{ \
if (_instance != 0) \
{ \
delete _instance; \
_instance = 0; \
} \
} //End of ALLOW_SINGLETON(ClassName);
#define IMPLEMENT_SINGLETON(ClassName); \
ClassName* ClassName::_instance = 0; \
static class DestructHelper_##ClassName \
{ \
public: \
~DestructHelper_##ClassName(){ ClassName::ReleaseInstance(); } \
} DestructHelperInstance_##ClassName;
//End of IMPLEMENT_SINGLE(ClassName);
class MySingleton4
{
private:
MySingleton4(){ cout << _T("Construct MySingleton4") << endl; } //构造函数私有
~MySingleton4(){ cout << _T("Destroy MySingleton4") << endl; } //析构函数放哪里都可以
ALLOW_SINGLETON(MySingleton4);
public:
void DoSomething(){ cout << _T("Do something here in MySingleton4") << endl; }
};
IMPLEMENT_SINGLETON(MySingleton4);
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//测试
void _tmain(int argc, char *argv[])
{
//测试第一种实现
cout << _T("**************Test of the first implementation***************") << endl;
MySingleton1* myobj1;
myobj1 = GetInstancePtr<MySingleton1>();
myobj1->DoSomething();
GetInstanceRef<MySingleton1>().DoSomething();
//测试第二种实现
cout << endl << _T("**************Test of the second implementation**************") << endl;
MySingleton2* myobj2;
myobj2 = SingletonWraper<MySingleton2>::GetInstancePtr();
myobj2->DoSomething();
//MySingleton2 myobj22(*myobj2); //Error
MySingleton2::SingletonInterface::GetInstanceRef().DoSomething();
//测试第三种实现
cout << endl << _T("**************Test of the third implementation***************") << endl;
MySingleton3 *myobj3 = MySingleton3::GetInstancePtr();
myobj3->ID = 1;
myobj3->DoSomething();
MySingleton3& myobj33 = MySingleton3::GetInstanceRef();
myobj33 = *myobj3;
try
{
delete myobj3;
}
catch(...)
{
cout << _T("Your object cannot be deleted.") << endl;
}
myobj33.ID = 2;
myobj33.DoSomething();
myobj3->DoSomething();
//测试第四种实现
cout << endl << _T("**************Test of the fourth implementation**************") << endl;
MySingleton4 *myobj4 = MySingleton4::GetInstancePtr();
myobj4->DoSomething();
MySingleton4::GetInstanceRef().DoSomething();
cout << _T("**********************End of all testing*********************") << endl << endl;
cout << _T("Following is the Automatic Garbage Collection process:") << endl << endl;
}
////////////////////////////////////////////////////////////////////
[附件二：演示程序运行结果]
**************Test of the first implementation***************
Construct MySingleton1
Do something here in MySingleton1
Do something here in MySingleton1
**************Test of the second implementation**************
Construct MySingleton2
Do something here in MySingleton2
Do something here in MySingleton2
**************Test of the third implementation***************
Construct MySingleton3
Do something here in MySingleton3, ID = 1
Destroy MySingleton3
Your object cannot be deleted.
Do something here in MySingleton3, ID = 2
Do something here in MySingleton3, ID = 2
**************Test of the fourth implementation**************
Construct MySingleton4
Do something here in MySingleton4
Do something here in MySingleton4
**********************End of all testing*********************
Following is the Automatic Garbage Collection process:
Destroy MySingleton3
Destroy MySingleton2
Destroy MySingleton1
Destroy MySingleton4
发表于 @ 2004年12月03日 14:28:00|评论(loading...)|编辑