1.什么是单例模式？

顾名思义，单例模式就是在这个单例类确保只有一个对象被创建。也就是说这个类只能实例化一个对象。

特征：1.单例类最多只能有一个实例； 2.单例类必须自己创建自己唯一的实例； 3.单例类必须给所有其他的对象提供这一实例。

2.为什么要有单例模式？

首先，单例模式中某一类只能实例化一个对象，然后该类提供了一个全局都可以访问的实例化静态对象，以此来应对程序中某些频繁销毁构建的全局类

优点：1.内存中该类只实例化了一个对象，减少了内存的消耗；2.避免资源的重复占用

缺点：单例类的话，不能被继承，因为它的构造函数那些东西都是私有(private)的；

3.应用场景

假如说我们现在要写一个连接数据库的程序，因为创建数据库链接对象非常消耗资源，如果我们每次都重复操作---->创建数据库链接对象，就会非常消耗内存资源，我们也可以发现，这个数据库链接是可以复用的，所以我们将对象设计成单例的，这样就可以重复使用这个对象就可以了，可以在很大程度上减少资源的消耗。

4.单例模式的实现

1.饿汉模式(空间换时间)：

将单例类的唯一对象实例，通过一个静态成员变量来实现，加载进程时即完成创建，无论用或不用该单例对象都一直存在。

class Chairman
{
public:
	void print()
	{
		cout << "对象调用" << endl;
	}
private:
	Chairman()  //私有构造函数
	{
		cout << "创建chairman类" << endl;
	}

public:
	static Chairman* singleman;  //类内声明chairman对象指针
};

Chairman* Chairman::singleman = new Chairman;  //类外进行初始化

int main()
{
	cout << "main函数开始执行" << endl;
	Chairman::singleman->print();

	system("pause");
	return 0;
}

上述代码的运行结果如下：

上述代码是先创建的chairman，然后才调用的main主函数，也就是说在预编译阶段已经将对象构建完成(这也是饿汉模式的特点)

但是饿汉模式也会有问题：当这个对象特别大的时候，无论你用不用该对象，在使用程序开始的那一课开始，对象已经存在，会造成巨大的内存浪费。

2.懒汉模式(时间换空间)

????????第一次用到类实例的时候才会去实例化，在还没使用到类实例的时候，它是不会进行实例化的。(只有在用到该类示例的时候才会进行实例化)。

class Chairman
{
public:
	void print()
	{
		cout << "对象调用" << endl;
	}
	static Chairman* getChairman()
	{
		if (Chairman::singleman == nullptr)
		{
			Chairman::singleman = new Chairman();
		}
		return Chairman::singleman;
	}
private:
	Chairman()  //私有构造函数
	{
		cout << "创建chairman类" << endl;
	}

private:
	static Chairman* singleman;
};

Chairman* Chairman::singleman = nullptr;

int main()
{
	cout << "main主函数开始调用" << endl;
	Chairman* c1 = Chairman::getChairman();
	c1->print();

	system("pause");
	return 0;
}

我们看一下上述代码的运行结果: