单例模式

【1】什么是单例模式？

  单例，即所谓，单个实例。换句话说，类也需要计划生育。

  单例模式即在应用程序中一个类有且仅有一个实例的一种设计模式。

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

  结合以上需求、编程经验，不难总结单例模式要点有三：

  一、某个类只能有一个实例。代码体现在构造函数访问属性为私有private，外界不可调用。另外，赋值操作也应该私有。

  二、必须自行创建这个实例。既然有要点一private的约束，那么，实例肯定得自给自足。

  三、必须自行向整个应用程序系统提供这个实例。为了便于外界访问，结合一二、这个供访问的接口设计为静态static成员函数。

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

示例代码：

#include <iostream>
using namespace std;

class Singleton
{
public:
    static Singleton *getInstance()
    {
        return m_pInstance;
    }
    void show()
    {
        cout << m_nValue << endl;
    }

private:
    int m_nValue;
    static Singleton *m_pInstance;
    Singleton(int value) : m_nValue(value)
    {}
};

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

class A : public Singleton
{

};

void main()
{
    Singleton *pObj1 = Singleton::getInstance();
    Singleton *pObj2 = A::getInstance();
    cout << pObj1 << endl;
    cout << pObj2 << endl;
    pObj1->show();
    pObj2->show();
    cout << (pObj1 == pObj2) << endl;
    system("pause");
}

// run result:
/*
004583F0
004583F0
8899
8899
1
请按任意键继续. . .
*/

【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()
{}

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

Good Good Study, Day Day Up.

顺序 选择 循环 总结