C++中的單例模式)

單例模式也稱為單件模式、單子模式，可能是使用最廣泛的設計模式。其意圖是保證一個類僅有一個執行個體，並提供一個訪問它的全域訪問點，該執行個體被所有程式模組共用。有很多地方需要這樣的功能模組，如系統的日誌輸出，GUI應用必須是單滑鼠，MODEM的聯結需要一條且只需要一條電話線，作業系統只能有一個視窗管理器，一台PC連一個鍵盤。

 

單例模式有許多種實現方法，在C++中，甚至可以直接用一個全域變數做到這一點，但這樣的代碼顯的很不優雅。 使用全域對象能夠保證方便地訪問執行個體，但是不能保證只聲明一個對象——也就是說除了一個全域執行個體外，仍然能建立相同類的本地執行個體。

《設計模式》一書中給出了一種很不錯的實現，定義一個單例類，使用類的私人靜態指標變數指向類的唯一執行個體，並用一個公有的靜態方法擷取該執行個體。

單例模式通過類本身來管理其唯一執行個體，這種特性提供瞭解決問題的方法。唯一的執行個體是類的一個普通對象，但設計這個類時，讓它只能建立一個執行個體並提供對此執行個體的全域訪問。唯一執行個體類Singleton在靜態成員函數中隱藏建立執行個體的操作。習慣上把這個成員函數叫做Instance()，它的傳回值是唯一執行個體的指標。

定義如下：

class CSingleton

{

//其他成員

public:

static CSingleton* GetInstance()

{

      if ( m_pInstance == NULL )  //判斷是否第一次調用

        m_pInstance = new CSingleton();

        return m_pInstance;

}

private:

    CSingleton(){};

    static CSingleton * m_pInstance;

};

註：cpp中要有如下代碼：

Singleton* Singleton::instance=NULL; 

使用者訪問唯一執行個體的方法只有GetInstance()成員函數。如果不通過這個函數，任何建立執行個體的嘗試都將失敗，因為類的建構函式是私人的。GetInstance()使用懶惰初始化，也就是說它的傳回值是當這個函數首次被訪問時被建立的。這是一種防彈設計——所有GetInstance()之後的調用都返回相同執行個體的指標：

CSingleton* p1 = CSingleton :: GetInstance();

CSingleton* p2 = p1->GetInstance();

CSingleton & ref = * CSingleton :: GetInstance();

對GetInstance稍加修改，這個設計範本便可以適用於可變多執行個體情況，如一個類允許最多五個執行個體。

 

單例類CSingleton有以下特徵：

它有一個指向唯一執行個體的靜態指標m_pInstance，並且是私人的；

它有一個公有的函數，可以擷取這個唯一的執行個體，並且在需要的時候建立該執行個體；

它的建構函式是私人的，這樣就不能從別處建立該類的執行個體。

 

大多數時候，這樣的實現都不會出現問題。有經驗的讀者可能會問，m_pInstance指向的空間什麼時候釋放呢？更嚴重的問題是，該執行個體的解構函式什麼時候執行？

如果在類的析構行為中有必須的操作，比如關閉檔案，釋放外部資源，那麼上面的代碼無法實現這個要求。我們需要一種方法，正常的刪除該執行個體。

可以在程式結束時調用GetInstance()，並對返回的指標掉用delete操作。這樣做可以實現功能，但不僅很醜陋，而且容易出錯。因為這樣的附加代碼很容易被忘記，而且也很難保證在delete之後，沒有代碼再調用GetInstance函數。

一個妥善的方法是讓這個類自己知道在合適的時候把自己刪除，或者說把刪除自己的操作掛在作業系統中的某個合適的點上，使其在恰當的時候被自動執行。

我們知道，程式在結束的時候，系統會自動析構所有的全域變數。事實上，系統也會析構所有的類的靜態成員變數，就像這些靜態成員也是全域變數一樣。利用這個特徵，我們可以在單例類中定義一個這樣的靜態成員變數，而它的唯一工作就是在解構函式中刪除單例類的執行個體。如下面的代碼中的CGarbo類（Garbo意為垃圾工人）：

class CSingleton

{

//其他成員

public:

static CSingleton* GetInstance();

private:

    CSingleton(){};

    static CSingleton * m_pInstance;

class CGarbo //它的唯一工作就是在解構函式中刪除CSingleton的執行個體

{

        public:

            ~CGarbo()

            {

                if( CSingleton::m_pInstance )

                  delete CSingleton::m_pInstance;

}

         }

        Static CGabor Garbo; //定義一個靜態成員，程式結束時，系統會自動調用它的解構函式

}；

類CGarbo被定義為CSingleton的私人內嵌類，以防該類被在其他地方濫用。

程式運行結束時，系統會調用CSingleton的靜態成員Garbo的解構函式，該解構函式會刪除單例的唯一執行個體。

使用這種方法釋放單例對象有以下特徵：

在單例類內部定義專有的嵌套類；

在單例類內定義私人的專門用於釋放的靜態成員；

利用程式在結束時析構全域變數的特性，選擇最終的釋放時機；

使用單例的代碼不需要任何操作，不必關心對象的釋放。

(出處：http://hi.baidu.com/csudada/blog/item/208fb0f56bb61266dcc47466.html)

進一步的討論

但是添加一個類的靜態對象，總是讓人不太滿意，所以有人用如下方法來重現實現單例和解決它相應的問題，代碼如下：

class CSingleton

{

    //其他成員

    public:

        static Singleton &GetInstance()

{

    static Singleton instance;

    return instance;

}

        private:

            Singleton() {};

};

使用局部靜態變數，非常強大的方法，完全實現了單例的特性，而且代碼量更少，也不用擔心單例銷毀的問題。

但使用此種方法也會出現問題，當如下方法使用單例時問題來了，

Singleton singleton = Singleton :: GetInstance();

這麼做就出現了一個類拷貝的問題，這就違背了單例的特性。產生這個問題原因在於：編譯器會為類產生一個預設的建構函式，來支援類的拷貝。

最後沒有辦法，我們要禁止類拷貝和類賦值，禁止程式員用這種方式來使用單例，當時領導的意思是GetInstance()函數返回一個指標而不是返回一個引用，函數的代碼改為如下：

static Singleton *GetInstance()

{

static  Singleton instance;

return  &instance;

}

但我總覺的不好，為什麼不讓編譯器不這麼幹呢。這時我才想起可以顯示的聲明類的複製建構函式，和重載 = 操作符，新的單例類如下：

class Singleton

{

    //其他成員

    public:

        static Singleton &GetInstance()

{

    static Singleton instance;

    return instance;

}

        private:

            Singleton() {};

            Singleton(const Singleton&);

            const Singleton & operator= (const Singleton&);

};

關於Singleton(const Singleton&); 和 const Singleton & operator= (const Singleton&);函數，需要聲明成私用的，並且只聲明不實現。這樣，如果用上面的方式來使用單例時，不管是在友元類中還是其他的，編譯器都是報錯。

不知道這樣的單例類是否還會有問題，但在程式中這樣子使用已經基本沒有問題了。

（出處：http://snailbing.blogbus.com/logs/45398975.html）

最佳化Singleton類，使之適用於單線程應用

Singleton使用操作符new為唯一執行個體分配儲存空間。因為new操作符是安全執行緒的，在多線程應用中你可以使用此設計範本，但是有一個缺陷：就是在應用程式終止之前必須手工用delete摧毀執行個體。否則，不僅導致記憶體溢出，還要造成不可預測的行為，因為Singleton的解構函式將根本不會被調用。而通過使用本地靜態執行個體代替動態執行個體，單線程應用可以很容易避免這個問題。下面是與上面的GetInstance()稍有不同的實現，這個實現專門用於單線程應用：

CSingleton* CSingleton :: GetInstance()

{

    static CSingleton inst；

    return &inst；

}

本地靜態對象執行個體inst是第一次調用GetInstance()時被構造，一直保持活動狀態直到應用程式終止，指標m_pInstance變得多餘並且可以從類定義中刪除掉，與動態指派至不同，靜態對象當應用程式終止時被自動銷毀掉，所以就不必再手動銷毀執行個體了。

（出處：http://blog.csdn.net/pingnanlee/archive/2009/04/20/4094313.aspx）

代碼學習（從http://apps.hi.baidu.com/share/detail/32113057引用）

 

[cpp] view plaincopy

1. //版本一  
2.   
3. #include <iostream>     
4.   
5. using namespace std;     
6.   
7. //單例類的C++實現     
8.   
9. class Singleton     
10.   
11. {     
12.   
13. private:     
14.   
15.        Singleton();//注意:構造方法私人     
16.   
17.             
18.   
19.        static Singleton* instance;//惟一執行個體     
20.   
21.        int var;//成員變數(用於測試)     
22.   
23. public:     
24.   
25.        static Singleton* GetInstance();//Factory 方法(用來獲得執行個體)     
26.   
27.        int getVar();//獲得var的值     
28.   
29.        void setVar(int);//設定var的值     
30.   
31.        virtual ~Singleton();  
32.   
33. };     
34.   
35. //構造方法實現     
36.   
37. Singleton::Singleton()     
38.   
39. {     
40.   
41.        this->var = 20;     
42.   
43.        cout<<"Singleton Constructor"<<endl;     
44.   
45. }     
46.   
47. Singleton::~Singleton()     
48.   
49. {     
50.   
51.        cout<<"Singleton Destructor"<<endl;  
52.   
53.        //delete instance;     
54.   
55. }     
56.   
57. //初始化靜態成員     
58.   
59. /*Singleton* Singleton::instance=NULL; 
60.  
61. Singleton* Singleton::GetInstance()    
62.  
63. {    
64.  
65.        if(NULL==instance) 
66.  
67.               instance=new Singleton(); 
68.  
69.        return instance;    
70.  
71. }*/  
72.   
73. Singleton* Singleton::instance=new Singleton;  
74.   
75. Singleton* Singleton::GetInstance()     
76.   
77. {     
78.   
79.        return instance;     
80.   
81. }       
82.   
83. //seter && getter含數     
84.   
85. int Singleton::getVar()     
86.   
87. {     
88.   
89.        return this->var;     
90.   
91. }     
92.   
93. void Singleton::setVar(int var)     
94.   
95. {     
96.   
97.        this->var = var;     
98.   
99. }     
100.   
101. //main     
102.   
103. void main()     
104.   
105. {     
106.   
107.        Singleton *ton1 = Singleton::GetInstance();     
108.   
109.        Singleton *ton2 = Singleton::GetInstance();  
110.   
111.       if(ton1==ton2)  
112.   
113.               cout<<"ton1==ton2"<<endl;  
114.   
115.        cout<<"ton1 var = "<<ton1->getVar()<<endl;  
116.   
117.        cout<<"ton2 var = "<<ton2->getVar()<<endl;     
118.   
119.        ton1->setVar(150);     
120.   
121.        cout<<"ton1 var = "<<ton1->getVar()<<endl;  
122.   
123.        cout<<"ton2 var = "<<ton2->getVar()<<endl;  
124.   
125.        delete Singleton::GetInstance();//必須顯式地刪除  
126.   
127. }