单例模式

什么是单例模式：

只能实例化一个类对象（全局有且只有一个类的static实例）

使用场景：

进程管理器、日志管理器、网站访问计数器、应用配置程序、线程池、服务器的连接管理器

实现单例模式的原理/步骤

1、禁止在类外随意实例化对象，把构造函数/拷贝构造都私有化private

2、确保类对象只有一份，在类中定义一个静态的类对象成员变量

3、需要提供一个换取静态类对象成员变量的公开接口，设计静态成员函数用于获取那唯一 的一个静态类对象

饿汉模式的单例：

程序运行开始时就立即实例化单例对象，不管后期是否用到都会完成实例化

缺点：如果后期并没有使用，就浪费资源、时间

优点：不可能被多个线程同时运行创建多份（线程安全）

#include <iostream>
using namespace std;

class Single
{
    static Single obj;    //定义一个静态成员变量
    Single(void)    //构造函数私有化
    {
        cout << "我是构造函数" << endl;    
    }
    Single(const Single& that)    //拷贝构造私有化
    {
        cout << "我是拷贝构造" << endl;    
    }
public:
    static Single& get_obj(void)    //设计静态成员函数作为接口
    {
        return obj;    
    }

    void show(void)
    {
        cout << &obj << endl;    
    }
};

Single Single::obj;    //静态成员初始化

int main(int argc,const char* argv[])
{
//    Single::obj;
    Single& s = Single::get_obj();
    s.show();
    Single& s1 = Single::get_obj();
    s1.show();
}

输出：

我是构造函数    //说明只实例化了一次
0x804a0d4
0x804a0d4

懒汉模式的单例：

什么时候使用，就什么时候实例化单例类对象

优点：使用时才会去创建，节约时间、资源

缺点：可能会被多个线程同时实例化，有可能会创建出多个单例类对象（线程不安全），

实例：

#include<iostream>
using namespace std;

class Single
{
    static Single* obj;
    Single(void)
    {
        cout << "我是构造函数" << endl;    
    }
    Single(const Single& that)
    {
        cout << "我是拷贝构造" << endl;    
    }
public:
    static Single& get_obj(void)
    {
        if(NULL == obj)
        {
            obj = new Single;    
        }
        return *obj;    
    }

    void show(void)
    {
        cout << obj << endl;    
    }
};

Single* Single::obj;

int main(int argc,const char* argv[])
{
    Single& s = Single::get_obj();
    s.show();
    Single& s1 = Single::get_obj(); 
    s1.show();
}