单例模式

分类： C++2011-08-11 15:58 117人阅读 评论(3) 收藏 举报

        单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。

        单例模式的要点有三个：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。 

        C++单例模式有许多种实现方法，在C++中，甚至可以直接用一个全局变量做到这一点，但这样的代码显得很不优雅。《设计模式》一书中给出了一种很不错的实现，定义一个单例类，使用类的私有静态指针变量指向类的唯一实例，并用一个公有静态方法获取该实例。

如下：单例模式程序一：

view plain print ?

1. Singleton.h文件：  
2. class CSingleTon  
3. {  
4. private:  
5.     CSingleTon(); //构造函数为私有的  
6. public:  
7.     ~CSingleTon();//析构函数是公有的  
8. public:  
9.     static CSingleTon* GetInstance();//用来获取实例，公有  
10.     int GetVar();           //获取m_num的值  
11.     void SetVar(int var);   //设置m_num的值  
12.     void Print();           //在控制台上打印m_num的值  
13. private:  
14.     static CSingleTon *m_pInstance; //类的唯一实例,私有  
15.     int m_var;  
16. };  

 

 

view plain print ?

1. Singleton.cpp  
2. #include <iostream>  
3. using namespace std;  
4. #include "singleton.h"  
5.   
6. CSingleTon *CSingleTon::m_pInstance = CSingleTon::GetInstance();//静态成员变量的初始化  
7.   
8. CSingleTon::CSingleTon()  
9. {  
10.     m_var = 0;  
11. }  
12.   
13. CSingleTon::~CSingleTon()  
14. {  
15.     if(m_pInstance != NULL)  
16.         delete m_pInstance;  
17. }  
18.   
19. void CSingleTon::SetVar(int var)  
20. {  
21.     m_var = var;  
22. }  
23.   
24. int CSingleTon::GetVar()  
25. {  
26.     return m_var;  
27. }  
28.   
29. CSingleTon* CSingleTon::GetInstance()  
30. {  
31.     if(m_pInstance == NULL)  
32.     {  
33.         m_pInstance = new CSingleTon();  
34.     }  
35.     return m_pInstance;  
36. }  
37.   
38. void CSingleTon::Print()  
39. {  
40.     cout<<m_var<<endl;  
41. }  

 

view plain print ?

1. Main.cpp  
2. #include <iostream>  
3. using namespace std;  
4.   
5. #include "singleton.h"  
6.   
7. int main(void)  
8. {  
9.     CSingleTon *tonfir = CSingleTon::GetInstance();  
10.     CSingleTon *tonsec = CSingleTon::GetInstance();  
11.   
12.     printf("%p\n%p\n", tonfir, tonsec); //打印两个单例类对象指针的地址  
13.     tonfir->Print();  
14.     tonfir->SetVar(5);  
15.     tonsec->Print();  
16.     delete tonfir;          //调用析构函数  
17.     delete tonsec;          //其实这句话可以不写,因为tonfir和tonsec指向的是同一个对象  
18.     return 0;  
19. }  

该单例类的特征：

       1.它有一个唯一实例的静态指针变量m_pInstance，并且是私有的；

       2.它有一个公有函数，用于获取这个唯一实例，并在需要的时候创建该实例；

       3.它的构造函数是私有的，这样就不能在别处创建该类的实例

       大多时候，这样的实现都不会出现问题。有经验的读者可能会问，m_pInstance指向的空间什么时候释放呢？更严重的问题是，这个实例的析构操作什么时候执行？如果在类的析构行为中有必须的操作，比如关闭文件，释放外部资源，那么上面所示的代码无法实现这个要求。我们需要一种方法，正常地删除该实例。

         可以在程序结束时调用GetInstance并对返回的指针调用delete操作。这样做可以实现功能，但是不仅很丑陋，而且容易出错。因为这样的附加代码很容易被忘记，而且也很难保证在delete之后，没有代码再调用GetInstance函数。

         一个妥善的方法是让这个类自己知道在合适的时候把自己删除。或者说把删除自己的操作挂在系统中的某个合适的点上，使其在恰当的时候自动被执行。

         我们知道，程序在结束的时候，系统会自动析构所有的全局变量。事实上，系统也会析构所有的类的静态成员变量，就像这些静态成员也是全局变量一样。利用这个特征，我们可以在C++单例模式类中定义一个这样的静态成员变量，而它的唯一工作就是在析构函数中删除单例类的实例。如下面的代码中的CGarbo类（Garbo意为垃圾工人）

view plain print ?

1. Singleton.h  
2. #pragma once  
3. class CSingleTon  
4. {  
5. private:  
6.     CSingleTon(); //构造函数为私有的  
7. public:           //析构函数要是公有的  
8.     ~CSingleTon();  
9. private:  
10.     static CSingleTon *m_pInstance;      //类的唯一实例  
11.     class CGarbo            //内部类，该类的唯一工作是在析构函数中删除CSingleTon的实例  
12.     {  
13.     public:  
14.         ~CGarbo()  
15.         {  
16.         //  if(CSingleTon::m_pInstance)             //  内部类不能去访问包含其类的非公有成员变量  
17.         //      delete CSingleTon::m_pInstance;  
18.             if(CSingleTon::GetInstance())  
19.                 delete CSingleTon::GetInstance();  
20.         }  
21.     };  
22.     static CGarbo Garbo;        //定义一静态成员，在程序结束时，系统会调用它的析构函数  
23.   
24. protected:  
25.     int m_num;  
26. public:  
27.     static CSingleTon* GetInstance(); //用来获取实例  
28.     void SetNum(int num);  //设置m_num的值  
29.     int GetNum();          //获取m_num的值  
30.     void PrintNum();       //在控制台上打印m_num的值  
31. };  

view plain print ?

1. Singleton.cpp  
2. #include "singleton.h"  
3. #include <iostream>  
4. using namespace std;  
5.   
6. CSingleTon *CSingleTon::m_pInstance = CSingleTon::GetInstance();//静态成员变量的初始化  
7.   
8. CSingleTon::CSingleTon()  
9. {  
10.     cout<<"Construct"<<endl;  
11.     this->m_num = 0;  
12. }  
13.   
14. CSingleTon::~CSingleTon()  
15. {  
16.     cout<<"Destruct"<<endl;  
17.     if(m_pInstance != NULL)  
18.         delete m_pInstance;  
19. }  
20.   
21. CSingleTon* CSingleTon::GetInstance()  
22. {  
23.     if(m_pInstance == NULL)  
24.     {  
25.         m_pInstance = new CSingleTon();  
26.     }  
27.     return m_pInstance;  
28. }  
29.   
30. void CSingleTon::SetNum(int num)  
31. {  
32.     this->m_num = num;  
33. }  
34.   
35. int CSingleTon::GetNum()  
36. {  
37.     return this->m_num;  
38. }  
39.   
40. void CSingleTon::PrintNum()  
41. {  
42.     cout<<this->m_num<<endl;  
43. }  

 

view plain print ?

1. Main.cpp  
2. #include <iostream>  
3.   
4. using namespace std;  
5.   
6. #include "singleton.h"  
7.   
8. int main(void)  
9. {  
10.     CSingleTon *tonfir = CSingleTon::GetInstance();  
11.     CSingleTon *tonsec = CSingleTon::GetInstance();  
12.       
13.     tonfir->PrintNum();  
14.     tonsec->PrintNum();  
15.     tonfir->SetNum(5);  
16.     tonsec->PrintNum();  
17.   
18.     return 0;  
19. }  

 

原理：

         程序运行结束时，系统自动析构所有的全局变量。也会析构所有类的静态成员变量。

         在程序运行结束时，系统会调用CSingleTon的静态成员Garbo的析构函数，该析构函数会删除单例的唯一实例。

使用这种方法释放单例对象有以下特征：

         1.在单例类内部定义专有的嵌套类

         2.在单例类内部定义私有的专门用于释放单例对象的静态成员

         3.利用程序在结束时，析构静态变量的特性，选择最终的释放时机

         4.使用C++单例模式的代码不需要任何操作，不必关心对象的释放