【C++设计模式】创建型模式 — 单例模式

1、什么叫单例模式？

单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。也就是说，在整个程序空间中，该类只存在一个实例对象。   

注意一下几点：

• 单例类只能由一个实例化对象。

• 单例类必须自己提供一个实例化对象。

• 单例类必须提供一个可以访问唯一实例化对象的接口。

单例模式分为懒汉和饿汉两种实现方式。

懒汉：故名思义，不到万不得已就不会去实例化类，也就是说在第一次用到类实例的时候才会去实例化一个对象。在访问量较小，甚至可能不会去访问的情况下，采用懒汉实现，这是以时间换空间。

饿汉：饿了肯定要饥不择食。所以在单例类定义的时候就进行实例化。在访问量比较大，或者可能访问的线程比较多时，采用饿汉实现，可以实现更好的性能。这是以空间换时间。

2、为什么使用单例模式？

• 在多个线程之间，比如初始化一次socket资源；比如servlet环境，共享同一个资源或者操作同一个对象

• 在整个程序空间使用全局变量，共享资源

• 大规模系统中，为了性能的考虑，需要节省对象的创建时间等等。

因为Singleton模式可以保证为一个类只生成唯一的实例对象，所以这些情况，Singleton模式就派上用场了。

3、实现单例步骤？

1. 构造函数私有化
2. 提供一个全局的静态方法
3. 在类中定义一个静态指针，指向本类的变量的静态变量指针。

4、基础单例

4.1 懒汉式单例

#include <iostream>
using namespace std;

//懒汉式
class SingeIton
{
//构造函数私有化
private:
    SingeIton()
    {
        m_singer = NULL;
        m_count = 0;
        cout<<"SingeIton...do"<<endl;
    }

public:
    //类中定义一个静态指针
    static SingeIton *getInstance()
    {
        if(m_singer == NULL)
        {
            m_singer = new SingeIton;
        }
        return m_singer;
    }

    //提供一个全局的静态方法
    static void printT()
    {
        cout<<"m_count:"<<m_count<<endl;
    }

private:
    static SingeIton *m_singer;
    static int m_count;
};

SingeIton *SingeIton::m_singer = NULL;//懒汉式，没有创建单例对象；
int SingeIton::m_count = 0;

int main()
{
    cout<<"演示 懒汉式"<<endl;
    SingeIton *p1 = SingeIton::getInstance();//只有在使用的时候才会创建
    SingeIton *p2 = SingeIton::getInstance();
    if(p1 != p2)
    {
        cout<<"不是同一个对象"<<endl;
    }
    else
    {
        cout<<"是同一个对象"<<endl;
    }

    p1->printT();
    p2->printT();

    system("pause");
    return 0;
}

结果显示：

演示 懒汉式
SingeIton...do
是同一个对象
m_count:0
m_count:0

4.2 饿汉模式

#include <iostream>
using namespace std;

//饿汉式
class SingeIton
{
//构造函数私有化
private:
    SingeIton()
    {
        m_singer = NULL;
        m_count = 0;
        cout<<"构造函数 SingeIton...do"<<endl;
    }

public:
    //类中定义静态指针
    static SingeIton *getInstance()
    {
        return m_singer;
    }

    static SingeIton FreeInstance()
    {
        if(m_singer != NULL)
        {
            delete m_singer;
            m_singer = NULL;
            m_count = 0;
        }
    }

    //提供一个全局的静态方法
    static void printT()
    {
        cout<<"m_count:"<<m_count<<endl;
    }

private:
    static SingeIton *m_singer;
    static int m_count;
};

SingeIton *SingeIton::m_singer = new SingeIton;//不管你创建不创建实例，均把实例new出来
int SingeIton::m_count = 0;

int main()
{
    cout<<"****演示 饿汉式****"<<endl;
    SingeIton *p1 = SingeIton::getInstance();//只有在使用的时候才会创建
    SingeIton *p2 = SingeIton::getInstance();
    if(p1 != p2)
    {
        cout<<"不是同一个对象"<<endl;
    }
    else
    {
        cout<<"是同一个对象"<<endl;
    }

    p1->printT();
    p2->printT();
    SingeIton::FreeInstance();
    SingeIton::FreeInstance();


    system("pause");
    return 0;
}

结果显示：

****演示 饿汉式****
是同一个对象
m_count:0
m_count:0