单例模式

【1】什么是单例模式？

  单例，即所谓单个实例。单例模式即一个类只有一个实例的一种设计模式。

  单例模式保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。

  显然单例模式的要点有三个：

  一是某个类只能有一个实例；

  二是它必须自行创建这个实例；

  三是它必须自行向整个系统提供这个实例。

【2】单例模式的代码示例：

示例代码：

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

class Singleton
{    
private:
    int i;
    static Singleton *instance;
    Singleton(int i)
    {
        this->i = i;
    }
public:
    static Singleton *getInstance()
    {
        return instance;
    }
    void show()
    { 
        cout << i << endl;
    }
};

Singleton* Singleton::instance = new Singleton(8899); 

class A : public Singleton
{

};

int main()
{
    Singleton *s = Singleton::getInstance();
    Singleton *s2 = A::getInstance();
    cout << s << endl;
    cout << s2 << endl;
    cout << (s == s2) << endl;
    return 0;
}

【3】单例模式的进化史

（1）代码1：

说明：饿汉式

class CSingleton
{
private:
    CSingleton()   //构造函数是私有的
    {
    }
    static CSingleton *m_pInstance;

public:
    static CSingleton *GetInstance()
    {
        return m_pInstance;
    }
};

CSingleton *CSingleton::m_pInstance = new CSingleton();

（2）代码2：

说明：懒汉式

class CSingleton
{
private:
    CSingleton()   //构造函数是私有的
    {
    }
    static CSingleton *m_pInstance;

public:
    static CSingleton *GetInstance()
    {
        if (NULL == m_pInstance)  //判断是否第一次调用
        {
            m_pInstance = new CSingleton();
        }
        return m_pInstance;
    }
};

CSingleton *CSingleton::m_pInstance = NULL;

（3）代码3：

说明：静态对象引用返回式
class CSingleton
{
private:
    CSingleton()   //构造函数是私有的
    {
    }

public:
    static CSingleton & GetInstance()
    {
        static CSingleton instance;   //局部静态对象
        return instance;
    }
};

4）代码4：

说明：静态对象指针返回式
class CSingleton
{
private:
    CSingleton()   //构造函数是私有的
    {
    }
public:
    static CSingleton * GetInstance()
    {
        static CSingleton instance;   //局部静态对象
        return &instance;
    }
};

5）代码5：

说明：静态对象引用返回式优化（禁止拷贝构造和赋值）
class CSingleton
{
private:
    CSingleton()   //构造函数是私有的
    {
    }
    CSingleton(const CSingleton &);
    CSingleton & operator = (const CSingleton &);
public:
    static CSingleton & GetInstance()
    {
        static CSingleton instance;   //局部静态对象
        return instance;
    }
};

（6）代码6：

说明：线程安全式单例类
struct CCriticalSection
{
    void Lock()
    {}
    void UnLock()
    {}
}；

class Lock
{
private:       
    CCriticalSection m_cs;
public:
    Lock(CCriticalSection  cs) : m_cs(cs)
    {
        m_cs.Lock();
    }
    ~Lock()
    {
        m_cs.UnLock();
    }
};

class Singleton
{
private:
    Singleton();
    Singleton(const Singleton &);
    Singleton& operator = (const Singleton &);

public:
    static Singleton *Instantialize();
    static Singleton *pInstance;
    static CCriticalSection cs;
};

Singleton* Singleton::pInstance = NULL;

Singleton* Singleton::Instantialize()
{
    if (pInstance == NULL)
    {   //double check
        Lock lock(cs);           //用lock实现线程安全，用资源管理类，实现异常安全
        //使用资源管理类，在抛出异常的时候，资源管理类对象会被析构，析构总是发生的无论是因为异常抛出还是语句块结束。
        if (pInstance == NULL)
        {
            pInstance = new Singleton();
        }
    }
    return pInstance;
}