所謂的單例模式，就是設計一個類，它在整個程式中只能有一個該類的例項存在，這就是單例模式。

C++實現單例模式的一般方法是將建構函式，拷貝建構函式以及賦值運算子函式宣告成private，從而禁止他人建立例項。否則如果上面三者不為私有，那麼他人就可以呼叫上面的三個函式來建立例項，就沒法實現單例模式。但是我們總歸是要建立一個類的，我們可以提供一個public的靜態方法來幫助我們獲得這個類唯一的一個例項化物件。

單例模式一般有兩種實現模式

• 餓漢模式：像一個餓漢一樣，不管需不需要用到例項都要去建立例項，即在類產生的時候就建立好例項，這是一種空間換時間的做法。作為一個餓漢而言，體現了它的本質——“我全都要”。 

• 懶漢模式：像一個懶漢一樣，需要用到建立例項了程式再去建立例項，不需要建立例項程式就“懶得”去建立例項，這是一種時間換空間的做法，這體現了“懶漢的本性”。

在這篇文章中，我們暫且只來討論餓漢模式

       餓漢模式的物件在類產生時候就建立了，一直到程式結束才會去釋放。即作為一個單例類例項，它的生存週期和我們的程式一樣長。因此該例項物件需要儲存在全域性資料區，所以肯定需要使用static來修飾，因為類內部的static成員是不屬於每個物件的，而是屬於整個類的。在載入類的時候，我們的例項物件就產生了。所以對於餓漢模式而言，是執行緒安全的，因為線上程建立之前例項已經被建立好了。

下面我們可以來模式實現一個餓漢模式的單例類

singleton.hpp

#pragma once

#include <iostream>
using namespace std;

class Singleton{
private:
    Singleton(){
        cout << "建立了一個單例物件" << endl;
    }
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
    ~Singleton(){
        //解構函式我們也需要宣告成private的
        //因為我們想要這個例項在程式執行的整個過程中都存在
        //所以我們不允許例項自己主動呼叫解構函式釋放物件
        cout << "銷燬了一個單例物件" << endl;
    }


    static Singleton instance;  //這是我們的單例物件，注意這是一個類物件，下面會更改這個型別
public:
    static Singleton* getInstance();
};

//下面這個靜態成員變數在類載入的時候就已經初始化好了
Singleton Singleton::instance; 

Singleton* Singleton::getInstance(){
    return &instance;
}
 

test.cc

#include "singleton.hpp"

int main(){
    cout << "Now we get the instance" << endl;
    Singleton* instance1 = Singleton::getInstance();
    Singleton* instance2 = Singleton::getInstance();
    Singleton* instance3 = Singleton::getInstance();
    cout << "Now we destroy the instance" << endl;
    return 0;
}

我們來看下執行結果

由此可見，對於我們的程式，在我們輸出Now we get the instance這句話的時候，也就是我們即將獲取到這個類物件的例項的時候，在這之前這個單例類的例項在載入類的時候已經被建立好了，且我們呼叫了三個getInstance來獲取例項，也並沒有因此而多建立更多的例項，因此它是一個單例類。在程式結束的時候，這個唯一的例項才會被銷燬。

上面我們在singleton.hpp 中實現的例項是一個類物件，現在我們看看來把它換成類物件的指標會怎麼樣

singleton.hpp

#pragma once

#include <iostream>
using namespace std;

class Singleton{
private:
    Singleton(){
        cout << "建立了一個單例物件" << endl;
    }
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
    ~Singleton(){
        //解構函式我們也需要宣告成private的
        //因為我們想要這個例項在程式執行的整個過程中都存在
        //所以我們不允許例項自己主動呼叫解構函式釋放物件
        cout << "銷燬了一個單例物件" << endl;
    }
    static Singleton* instance;  //這是我們的單例物件,它是一個類物件的指標
public:
    static Singleton* getInstance();
};

//下面這個靜態成員變數在類載入的時候就已經初始化好了
Singleton* Singleton::instance = new Singleton(); 

Singleton* Singleton::getInstance(){
    return instance;    //這裡就是直接返回instance了而不是返回&instance
}

測試程式不變，我們再來看一下程式執行結果

 這是怎麼回事？？？程式居然沒有呼叫解構函式？？那麼會有什麼後果？沒有釋放佔有的資源，導致記憶體洩漏！！

這是為什麼呢？因此此時全域性資料區中，儲存的並不是一個例項物件，而是一個例項物件的指標，它是一個地址而已，我們真正佔有資源的例項物件是儲存在堆中的。這樣的宣告方法可以減小全域性資料區的佔用量，把一大堆單例物件放在了堆中，但我們需要主動地去呼叫delete釋放申請的資源。我們想要手動呼叫delete 直接釋放該例項是不可能的，因為它的解構函式是私有的，調不到解構函式（解構函式是私有也是我們要求的）。

delete Singleton::getInstance;    //這編譯不過，調不到解構函式

方法一：在類中再寫一個主動釋放資源的方法

singleton.hpp

#pragma once

#include <iostream>
using namespace std;

class Singleton{
private:
    Singleton(){
        cout << "建立了一個單例物件" << endl;
    }
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
    ~Singleton(){
        //解構函式我們也需要宣告成private的
        //因為我們想要這個例項在程式執行的整個過程中都存在
        //所以我們不允許例項自己主動呼叫解構函式釋放物件
        cout << "銷燬了一個單例物件" << endl;
    }
    static Singleton* instance;  //這是我們的單例物件,它是一個類物件的指標
public:
    static Singleton* getInstance();
    static void deleteInstance();   //用來銷燬例項
};

//下面這個靜態成員變數在類載入的時候就已經初始化好了
Singleton* Singleton::instance = new Singleton(); 

Singleton* Singleton::getInstance(){
    return instance;   
}
void Singleton::deleteInstance(){
    delete instance;
}

test.cc

#include "singleton.hpp"

int main(){
    cout << "Now we get the instance" << endl;
    Singleton* instance1 = Singleton::getInstance();
    Singleton* instance2 = Singleton::getInstance();
    Singleton* instance3 = Singleton::getInstance();
    cout << "Now we destroy the instance" << endl;
    Singleton::deleteInstance();
    return 0;
}

程式執行結果如下圖

但是這就讓很多程式設計師不爽了，因為他們（哈哈當然還有我）總是會忘記手動去呼叫函式來釋放資源。於是我們想到了，可不可以有一個自動地能夠釋放資源的函式。

方法二： 定義一個內部的類

singleton.hpp

#pragma once

#include <iostream>
using namespace std;

class Singleton{
private:
    Singleton(){
        cout << "建立了一個單例物件" << endl;
    }
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
    ~Singleton(){
        //解構函式我們也需要宣告成private的
        //因為我們想要這個例項在程式執行的整個過程中都存在
        //所以我們不允許例項自己主動呼叫解構函式釋放物件
        cout << "銷燬了一個單例物件" << endl;
    }

    static Singleton* instance;  //這是我們的單例物件,它是一個類物件的指標
public:
    static Singleton* getInstance();

    
private:
    //定義一個內部類
    class Garbo{
    public:
        Garbo(){}
        ~Garbo(){
            if(instance != NULL){
                delete instance;
                instance = NULL;
            }
        }
    };

    //定義一個內部類的靜態物件
    //當該物件銷燬的時候，呼叫解構函式順便銷燬我們的單例物件
    static Garbo _garbo;
};

//下面這個靜態成員變數在類載入的時候就已經初始化好了
Singleton* Singleton::instance = new Singleton(); 
Singleton::Garbo Singleton::_garbo;     //還需要初始化一個垃圾清理的靜態成員變數

Singleton* Singleton::getInstance(){
    return instance;   
}

test.cc

#include "singleton.hpp"

int main(){
    cout << "Now we get the instance" << endl;
    Singleton* instance1 = Singleton::getInstance();
    Singleton* instance2 = Singleton::getInstance();
    Singleton* instance3 = Singleton::getInstance();
    cout << "Now we destroy the instance" << endl;
    return 0;
}

程式執行結果如下

我們成功地銷燬了物件，而且還沒有手動去釋放！Perfect！當然了，我們想到，為什麼不嘗試用一用智慧指標呢？智慧指標不就是為了能夠讓我們不需要手動釋放資源而設計的麼，它會自動去釋放資源啊？關於智慧指標的問題，不懂的朋友去看一看我的另一篇部落格： C++中的智慧指標。現在我們嘗試著用智慧指標試試建立一個單例類。

singleton.hpp

#pragma once

#include <iostream>
#include <memory>
using namespace std;

class Singleton{
private:
    Singleton(){
        cout << "建立了一個單例物件" << endl;
    }
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
    ~Singleton(){
        //解構函式我們也需要宣告成private的
        //因為我們想要這個例項在程式執行的整個過程中都存在
        //所以我們不允許例項自己主動呼叫解構函式釋放物件
        cout << "銷燬了一個單例物件" << endl;
    }

    static shared_ptr<Singleton> instance;  //這是我們的單例物件,它是一個類物件的指標
public:
    static shared_ptr<Singleton> getInstance();
};
    

//下面這個靜態成員變數在類載入的時候就已經初始化好了
shared_ptr<Singleton> Singleton::instance(new Singleton()); 

shared_ptr<Singleton> Singleton::getInstance(){
    return instance;    
}

test.cc

#include "singleton.hpp"

int main(){
    cout << "Now we get the instance" << endl;
    shared_ptr<Singleton> instance1 = Singleton::getInstance();
    shared_ptr<Singleton> instance2 = Singleton::getInstance();
    shared_ptr<Singleton> instance3 = Singleton::getInstance();
    cout << "Now we destroy the instance" << endl;
    return 0;
}

你會發現它甚至連編譯都過不了，原因是shared_ptr無法訪問私有化的解構函式。但是我們又需要解構函式是私有的，這就矛盾起來了（為什麼希望解構函式是私有的如上註釋）。因此，我們就需要用到shared_ptr可以指定刪除器的特點，自定義刪除器。

方法三：shared_ptr與自定義刪除器

singleton.hpp

#pragma once

#include <iostream>
#include <memory>
using namespace std;

class Singleton{
private:
    Singleton(){
        cout << "建立了一個單例物件" << endl;
    }
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);
    ~Singleton(){
        //解構函式我們也需要宣告成private的
        //因為我們想要這個例項在程式執行的整個過程中都存在
        //所以我們不允許例項自己主動呼叫解構函式釋放物件
        cout << "銷燬了一個單例物件" << endl;
    }
    static void DestroyInstance(Singleton*);    //自定義一個釋放例項的函式

    static shared_ptr<Singleton> instance;  //這是我們的單例物件,它是一個類物件的指標
public:
    static shared_ptr<Singleton> getInstance();
};
    

//下面這個靜態成員變數在類載入的時候就已經初始化好了
shared_ptr<Singleton> Singleton::instance(new Singleton(),Singleton::DestroyInstance); 

shared_ptr<Singleton> Singleton::getInstance(){
    return instance;    
}
void Singleton::DestroyInstance(Singleton*){
    cout << "在自定義函式中釋放例項" << endl;
}

test.cc

#include "singleton.hpp"

int main(){
    cout << "Now we get the instance" << endl;
    shared_ptr<Singleton> instance1 = Singleton::getInstance();
    shared_ptr<Singleton> instance2 = Singleton::getInstance();
    shared_ptr<Singleton> instance3 = Singleton::getInstance();
    cout << "Now we destroy the instance" << endl;
    return 0;
}

程式的執行結果如下

好了，餓漢模式的單例類講完了，因為單例模式在程式一開始就初始化好例項，所以後續不再需要考慮執行緒安全的問題，因此它適用於執行緒比較多的程式中，以空間換取時間，提高了效率。

但在懶漢模式中，情況就不一樣了，因為它是在使用時才建立例項，在第一次呼叫getInstance()的時候，才建立例項物件。如果有多個執行緒，同時呼叫了getInstance()獲取例項，那麼可能就會產生多個例項，那麼這就不是我們的單例模式了。因此我們需要做一點事情，才能夠避免這種情況的發生。可以看看我的下一篇文章單例模式的懶漢模式