C++實現單例模式

昨天面試的時候，面試官讓我用C++或Java實現一個單例模式。

因為設計模式是在12年的時候學習過這門課，而且當時覺得這門課很有意思，所以就把課本讀了幾遍，所以印象比較深刻，但是因為實際編程中很少注意使用，所以沒能編碼實現。

這是之前用C#寫的一個單例模式的文章：http://www.cnblogs.com/CheeseZH/archive/2012/05/14/2500546.html

什么是單例模式

單件模式（SingletonPattern）：確保一個類只有一個實例，並提供一個全局訪問點。和全局變量一樣方便，又沒有全局變量的缺點，即不需要從一開始就創建對象，而是在需要時才創建它。

那么要如何保證一個類只能被實例化一次呢？一般情況下，如果存在一個類，我們都是可以多次地實例化它的。那么如果這樣呢：

public MyClass{
    private MyClass(){
    }
}

咦？構造函數私有？含有私有的構造器的類應該是不能被其他類實例化的，因為只有MyClass內部的代碼才能調用這個私有的構造函數。雖然只有MyClass類的實例才能調用MyClass構造器，但在這之前，必須有一個MyClass實例。然而這個類又不能被實例化，這樣就產生了矛盾！

看下面這段代碼：

public MyClass{
    public static MyClass getInstance(){
    }
}

上面的代碼表示MyClass有一個靜態方法，我們可以這樣調用這個方法：MyClass.getInstance(); 因為getInstance()是一個靜態方法，換句話說，是一個“類”方法。引用一個靜態方法，你需要使用類名，而不是對象名。

那么把上面兩段代碼合在一起，是否就可以使MyClass只產生一個實例了呢？

看下面的代碼：

public class MyClass{
       //利用一個靜態變量來記錄MyClass類的唯一實例
       private static MyClass uniqueInstance;
       //私有構造函數，只有自MyClass類內才可以調用
       private MyClass() {}
       //用getInstance靜態方法實例化對象，並返回
       public static MyClass getInstance(){
                if(uniqueInstance == NULL)
                {
                      uniqueInstance = new MyClass();
                }
                return uniqueInstance;
       }
       //當然，單件類也是一個正常的類，具有其他的變量和方法
       //...
}

這就是一個經典的單件模式的實現！之所以實例唯一，是因為單件類沒有公開的構造器，其他類不能自行將其實例化得到一個實例，而必須通過它的靜態方法getInstance()去創建一個實例。

C++完整實現

Singleton.h

#pragma once

class Singleton{
private:
    Singleton();
    ~Singleton();
    static Singleton* uniqueInstance;

public:
    static Singleton* getInstance();
    // other methods...
};

Singleton.cpp

#include"Singleton.h"
#include<iostream>
using namespace std;

Singleton::Singleton(){

}

Singleton::~Singleton(){
    if(uniqueInstance == NULL){
        return;
    }
    delete uniqueInstance;
    uniqueInstance = 0;
}

Singleton* Singleton::getInstance(){
    if(uniqueInstance == NULL){
        uniqueInstance = new Singleton;
    }
    return uniqueInstance;
}

main.cpp

#include<iostream>
#include"Singleton.h"
using namespace std;

Singleton* Singleton::uniqueInstance = NULL;

int main(){
    Singleton* singleton1 = Singleton::getInstance();
    Singleton* singleton2 = Singleton::getInstance();
    if(singleton1 == singleton2){
        cout<<"Got same singleton!!"<<endl;
    }
    else{
        cout<<"Oh,no!got a different singleton!!"<<endl;
    }
    return 0;
}

 一個完整的單例模式代碼：

#include<iostream>
using namespace std;
class CSingleton
{
private:
    CSingleton() {
    }
    ~CSingleton() {
        if (m_pInstance == NULL) {
            return;
        }
        delete m_pInstance;
        m_pInstance = NULL;
    }
    static CSingleton *m_pInstance;
public:
    static CSingleton * GetInstance() {
        if(m_pInstance == NULL)
            m_pInstance = new CSingleton();
        return m_pInstance;
    }
};
CSingleton* CSingleton::m_pInstance = NULL;//類的靜態成員變量需要在類外邊初始化

int main() {

    CSingleton* single1 = CSingleton::GetInstance();
    CSingleton* single2 = CSingleton::GetInstance();

    if (single1 == single2) {
        cout<<"Same"<<endl;
    }
    return 0;
}