设计模式：单例模式

单例模式：
单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方式。

单例模式主要有两种实现方式，懒汉式和饿汉式。

饿汉式:一上来就获取资源

饿汉是线程安全的

//饿汉式
class Singleton_hungry{
private:
	Singleton_hungry(){ cout << "我是饿汉" << endl;}
public:
	static Singleton_hungry* getInstance(){
		return pSingleton;
	}
private:
	static Singleton_hungry* pSingleton;
}
Singleton_hungry* Singleton_hungry::pSingleton = new Singleton_hungry;

懒汉式:调用时才获取资源

class Singleton_lazy{
private:
	Singleton_lazy(){cout << "我是懒汉" << endl;}
public:
	static Singleton_lazy* getInstance(){
		if(pSingleton == NULL){
			pSingleton = new Singleton_lazy;
		}
		return pSingleton;
	}
private:
	static Singleton_lazy* pSingleton;
}
Singleton_lazy* Singleton_lazy::pSingleton = NULL;

线程安全的懒汉单例(双检测法)：

class Singleton  
{  
private:  
    static Singleton* m_instance;  
    Singleton(){}  
public:  
    static Singleton* getInstance();  
};  
Singleton* Singleton::m_instance = NULL;
mutex t;
Singleton* Singleton::getInstance()  
{  
    if(m_instance == NULL)  
    {  
        t.lock();
        if(m_instance == NULL)  
        {  
            m_instance = new Singleton;  
        }  
        t.unLock();  
    }  
    return m_instance;  
}  

为什么单例模式中的成员函数都是静态的？

你只要弄明白单例模式是如何实现的，就能从本质上理解这个问题；

单例模式实现过程如下：

首先，将该类的构造函数私有化（目的是禁止其他程序创建该类的对象）；

其次，在本类中自定义一个对象（既然禁止其他程序创建该类的对象，就要自己创建一个供程序使用，否则类就没法用，更不是单例）；

最后，提供一个可访问类自定义对象的类成员方法（对外提供该对象的访问方式）。

直白的讲就是，你不能用该类在其他地方创建对象，而是通过该类自身提供的方法访问类中的那个自定义对象。

那么问题的关键来了，程序调用类中方法只有两种方式，①创建类的一个对象，用该对象去调用类中方法；②使用类名直接调用类中方法，格式“类名.方法名()”；

上面说了，构造函数私有化后第一种情况就不能用，只能使用第二种方法。

而使用类名直接调用类中方法，类中方法必须是静态的，而静态方法不能访问非静态成员变量，因此类自定义的实例变量也必须是静态的。

这就是单例模式唯一实例必须设置为静态的原因。
https://www.cnblogs.com/xqn2017/p/8029455.html