###單例模式
單例模式是一種常見的設計模式
表示的含義是某一個類，在一個程序中只有唯一的一個物件,並且在語法角度上進行制約

• 一個類只能例項化出一個物件
• 必須由自己進行建立
• 它必須向整個系統提供訪問介面

（方案一）餓漢模式

物件定義後資料立即載入到記憶體，以空間換時間的做法

class Singleton_1                                                                                                                                              
{                                                                                                                                                              
  public:                                                                                                                                                      
    static Singleton_1 *GetInstance()//靜態的成員函式,為外部提供介面                                                                                       
    {                                                                                                                                                          
      return _inst;                                                                                                                                            
    }
  protected:
	  Singleton_1() {};                                                                                                                                                            
  private:                                                                                                                                                                                                                                                                                         
    Singleton_1(const Singleton_1 & ) = delete;                                                                                                                
    Singleton_1 operator = (const Singleton_1 &) = delete;                                                                                                     
    static Singleton_1  *_inst;//靜態資料員。在該類範圍中只能定義一個                                                                                                                                                                                                                                                                                             
};                                                                                                                                                             
                                                                                                                                                               
//需要先對靜態成員進行初始化                                                                                                                                   
Singleton_1  *Singleton_1:: _inst =  new Singleton_1();                                                                                                        
//得到唯一的物件                                                                                                                                               
Singleton_1 * inst_ptr = Singleton_1::GetInstance();  
 

舉例驗證

#include <stdio.h>
#include <iostream>
using namespace std;

template <class T>                                                                                                                                             
//類模板                                                                                                                                                       
class Singleton_1                                                                                                                                              
{                                                                                                                                                              
  public:                                                                                                                                                      
    static T *GetInstance()//靜態的成員函式，用於訪問 T 資料                                                                                                   
    {                                                                                                                                                          
      return _inst;                                                                                                                                            
    }                                                                                                                                                          
                                                                                                                                                               
  private:                                                                                                                                                     
    Singleton_1(const T & ) = delete;                                                                                                                          
    Singleton_1 & operator = (const T &) = delete;                                                                                                             
    static T* _inst;//靜態資料員。在該類範圍中只能定義一個                                                                                                     
  protected:                                                                                                                                                   
    Singleton_1() {};                                                                                                                                             
    //建構函式設為保護的是為了繼承下去                                                                                                                       
    //這裡採用靜態成員意為 定義多個Signleton物件只能定義出一個T物件                                                                                            
};                                                                                                                                                             
                                                                                                                                                               
                                                                                                                                                               
//需要先對靜態成員進行初始化                                                                                                                                   
template<class T>                                                                                                                                              
T *Singleton_1<T>:: _inst = new T();                                                                                                                           
//規定 T 類物件只能通過 Signleton物件定義出來                                                                                                                  
//獲得唯一的物件                                                                                                                                               
int main()                                                                                                                                                     
{                                                                                                                                                              
  int * ret_ptr_1 = Singleton_1<int>::GetInstance();                                                                                                           
  int * ret_ptr_2 = Singleton_1<int>::GetInstance();                                                                                                           
  *ret_ptr_2 = 9;                                                                                                                                              
  *ret_ptr_1 = 8;                                                                                                                                              
  printf("ret_1 :%d\n",*ret_ptr_1);                                                                                                                            
  printf("ret_2 :%d\n",*ret_ptr_2);                                                                                                                            
  printf("ret_ptr_1 :%p\n",ret_ptr_1);                                                                                                                         
  printf("ret_ptr_2 :%p\n",ret_ptr_2);                                                                                                                         
  return 0;                                                                                                                                                    
}                 
 

結果顯示：

ret_1 :8
ret_2 :8
ret_ptr_1 :0x12c7c20
ret_ptr_2 :0x12c7c20

餓漢模式是一種執行緒安全的模式

（方案二）懶漢模式

物件定義出來 先不著急載入到記憶體，等到第一次使用的時候，再將資料載入到記憶體，以時間換空間的做法，其實也是一種延時載入

class Singleton_2                                                                                                                                              
{                                                                                                                                                              
  public:                                                                                                                                                      
    static Singleton_2 *GetInstance()                                                                                                                          
    {                                                                                                                                                          
      if(_inst == NULL)                                                                                                                                        
      {//定義的時候先沒有開闢空間，只有在用的時候進行呼叫                                                                                                      
        //多次呼叫的時候，若不為空可以直接返回                                                                                                                 
        _inst = new Singleton_2();                                                                                                                             
      }                                                                                                                                                        
      return _inst;                                                                                                                                            
    };                                                                                                                                                         
  protected:                                                                                                                                                   
    Singleton_2(){};                                                                                                                                             
  private:                                                                                                                                                     
    static Singleton_2 * _inst;                                                                                                                                
    Singleton_2(const Singleton_2 &) = delete; //防止拷貝                                                                                                      
    Singleton_2 operator = (const Singleton_2 &) = delete; //防止賦值                                                                                          
};                                                                                                                                                             
                                                                                                                                                               
//靜態成員需要先進行初始化為NULL                                                                                                                               
Singleton_2 * Singleton_2::_inst = NULL;                                                                                                                       
                                                                                                                                                               
Singleton_2 * inst_ptr= Singleton_2::GetInstance();           

##注意

1. 這種懶漢單例模式並不是一個執行緒安全模式，因為在判斷_inst是否為空和開闢空間並不是原子操作
2. 若是兩個執行緒都執行到判斷這一步，就會建立兩個物件,就會出現邏輯錯誤
3. 所以要在判斷和建立物件時加上互斥鎖
4. 有為了效率問題，我們只需要在_inst為空的時候再進行加鎖
5. 又為了防止編譯器過度優化，我們確保每次判斷的時候值都是從記憶體中讀取的，我們需要對私有成員加上 volatile關鍵字

（方案三）執行緒安全的懶漢模式

//執行緒安全的機制的懶漢模式

class Singleton_3
{
  public:
    static pthread_mutex_t lock;

    volatile  static Singleton_3 * GetInstance()
    {
      if(_inst == NULL)
      {
        //每次先判斷為空，即還有沒開闢空間的時候，在實施執行緒安全的措施
        //否則的話，每一次呼叫函式的的時候都判斷就太浪費資源了
        pthread_mutex_lock(&lock);
        if(_inst == NULL)
        {
          _inst = new Singleton_3();
        }
        pthread_mutex_unlock(&lock);
      }
      return  _inst;
    }

  protected:
    //在建構函式種對互斥鎖進行初始化
    Singleton_3()
    {
      pthread_mutex_init(&lock,NULL);
    };
  private:
    volatile static  Singleton_3 * _inst;
    //防止編譯器進行優化
    Singleton_3(const Singleton_3 &) = delete;
    Singleton_3 * operator =(const Singleton_3 &) = delete;
};

//對靜態成員的初始化
pthread_mutex_t Singleton_3:: lock ;
volatile Singleton_3 * Singleton_3:: _inst = NULL;


int main()
{
  volatile Singleton_3 * ret_ptr_1  = Singleton_3 ::GetInstance();
  volatile Singleton_3 * ret_ptr_2  = Singleton_3 ::GetInstance();
  volatile Singleton_3 * ret_ptr_3  = Singleton_3 ::GetInstance();

  printf("ret_ptr_1 ：%p\n",ret_ptr_1);
  printf("ret_ptr_2 ：%p\n",ret_ptr_2);
  printf("ret_ptr_3 ：%p\n",ret_ptr_3);

  return 0;
}

結果：

ret_ptr_1 ：0xbadc20
ret_ptr_2 ：0xbadc20
ret_ptr_3 ：0xbadc20