C++单例模式：Singleton Pattern

经典的单例模式实现：

class Singleton {
public:
    static Singleton* getInstance()
    {
        if(null == uniqueInstance)
        {
            /*
             * 如果单例不存在，就创建。如果暂时不需要这个实例，
             * 它就永远不会被创建。这就是“延迟实例化”。
            */
            uniqueInstance = new Singleton();
        }

        return uniqueInstance;
    }

private:
    Singleton();
    static Singleton* uniqueInstance;
};

单例模式：确保一个类只有一个实例，保证内存中任何情况下最多只有一个实例，并提供一个全局访问点。

单例模式的类的构造函数是私有的。

通过调用getInstance()静态方法来获取对象，由于是静态方法，所以可以在任何需要单例对象的时候来获得它。

饿汉式：

#ifndef HUNGRYSINGLETON_H
#define HUNGRYSINGLETON_H

/*
 * 饿汉式
 *
 * 饿汉式单例模式就是在类加载的时候就立即初始化并且创建单例对象。不管你有没有用到，都先建好了再说。它绝对线程安全，在线程还没出现以前就实例化了，不可能存在访问安全问题。
 * 优点：线程安全，没有加任何锁、执行效率比较高。
 * 缺点：类加载的时候就初始化，不管后期用不用都占着空间，浪费了内存。
 *
 * 饿汉式单例适合用在单例类比较少的情况下，在实际项目中，有可能会存在很多的单例类，如果我们都使用饿汉式单例的话，对内存的浪费会很大，所以，我们要学习更优的写法。
*/

#include <iostream>
using namespace std;

class HungrySingleton {
    // 先属性，后方法
    // 先上后下
private:
    static HungrySingleton* m_hungrySingleton = new HungrySingleton();

    HungrySingleton();

public:
    static HungrySingleton* getInstance();
};

HungrySingleton* HungrySingleton::getInstance()
{
    return m_hungrySingleton;
}


#endif // HUNGRYSINGLETON_H

懒汉式：

#ifndef LAZYSINGLETON_H
#define LAZYSINGLETON_H

/*
 *  懒汉式
 *
 * 懒汉式，顾名思义就是实例在需要用到的时候才去创建，“比较懒”，用的时候才去检查有没有实例，如果有则直接返回，没有则新建。
 *
 * 如此写法不是线程安全的，如果多个线程同时走到"null == m_lazySinglenton"且还没有实例化对象，就都判断为true，就会导致各个线程各自创建了一个实例，就不是单例了。
 *
 * 改善：加锁
*/


#include <iostream>
using namespace std;

class LazySingleton {
public:
    static LazySingleton* getInstance();

private:
    LazySingleton();
    static LazySingleton* m_lazySinglenton;
};

LazySingleton* LazySingleton::getInstance()
{
    if(null == m_lazySinglenton)
    {
        m_lazySinglenton = new LazySingleton();
    }

    return m_lazySinglenton;
}

#endif // LAZYSINGLETON_H