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;
}