单例模式入门

概念：单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例。

实现方式：实现单例模式通常有两种方式，一种是饿汉方式，另一种是懒汉方式。饿汉方式是指在main函数开始之前创建实例，优点是能避免多进程多线程异步IO，缺点是实例伴随整个程序的生命周期，消耗资源。懒汉方式是指在程序第一次调用getInstance函数时创建实例，优点是减小系统的资源消耗，缺点是当未提供同步IO方案时，可能出现多个实例的现象。

写饿汉模式的步骤：
1、在类的内部，定义私有的构造函数、拷贝构造函数、析构函数。
2、在类的内部，定义私有的指向实例化对象的静态指针；在类的外部，初始化该静态指针(在堆上创建该类唯一的实例化对象)。
3、在类的内部，定义公有的返回对象地址的静态成员函数getInstance()。

用C++语言实现一个简单的单例模型（饿汉）， 代码如下：

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

class President
{
public:
    static President *getInstance() //对应步骤三
    {
        return mPresident;
    }
    void Speak(const string &str)
    {
        cout << "Mr.president said : " << str << "." << endl;
    }
private:
    President(){}  //对应步骤一
    President(const President &president) {} //对应步骤一
    ~President(){} //对应步骤一
private:
    string mName;
    int age;
    static President *mPresident; //对应步骤二
};

President *President::mPresident = new President; //对应步骤二

void test()
{
    President *p1 = President::getInstance();
    President *p2 = President::getInstance();
    p1->Speak("同志们好！");
    p2->Speak("空谈误国，实干兴邦");
    if (p1 == p2)
        cout << "同一个实例" << endl;
    else
        cout << "不同的实例" << endl;
}

int main(void)
{
    test();
    return 0;
}

test()运行结果：

私有构造函数：使得在类外无法实例化对象。

私有拷贝构造函数：使得无法通过已有的对象来实例化对象。

私有析构函数：使得堆上的实例化对象在程序运行过程中无法被释放。

在类的内部，定义私有的指向实例化对象的静态指针：用于保存在堆上创建的对象的地址

在类的外部，初始化该静态指针：静态成员初始化在main函数之前，又因为静态指针是成员变量，因此可以调用私有的构造函数。

静态成员函数getInstance()：操作静态指针，返回唯一的实例化对象。

#include <iostream>
using namespace std;

class Demo
{
public:
    static Demo *getInstance() //第一次调用时创建实例
    {
        if (NULL == pInstance)
        {
            pInstance = new Demo;
        }
        return pInstance;
    }
private:
    Demo(){}
    Demo(const Demo &demo) {}
    ~Demo(){}
private:
    static Demo *pInstance;
};

Demo *Demo::pInstance = NULL;

int main(void)
{
    Demo *p = Demo::getInstance();
    Demo *p1 = Demo::getInstance();
    return 0;
}

通过如上操作，这个类就只能创建一个实例化对象。这就是单例模型。