Singleton模式的C++实现研究(示例代码)

类别:编程语言 点击:0 评论:0 推荐:

[附件一:演示程序代码清单]

/*//////////////////////////////////////////////////////////////////

作者:张友邦

时间: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

本文地址:http://com.8s8s.com/it/it29526.htm