=======================================

一 单例设计模式

1 单例设计模式的应用场景之一

任务管理器,我们电脑里只能打开一个,因为任务管理器是向内核请求

数据的,而我们打开多个,如果这时候卡了,

那么就会出现不同步的情况,如果这时候卡了,那么就会出现不同步的

情况,那么这时候,就会出现歧义,用户就看懵逼了.

所以需要保证全局只有一个对象

2 单例设计模式实现原理

(1) 通过把类A构造函数私有化,外部不能创建类A,但类内可创建

这样就确保类不能被外部创建

(2) 在类的内部创建一个私有的本类的实例,用静态指针变量接受

,用静态指针变量接受可以防止二次创建

(3) 提供一个静态公有的方法返回创建的实例,这样获取的对象是

唯一的

3 单例设计模式代码

   单例设计模式分为饿汉和懒汉式

饿汉式是在编译的时候就已经确定了唯一的实例了(开辟了空间)

懒汉式是创建实例的时候先初始化null,等使用的时候再创建

#include <iostream>
using namespace std;


//饿汉式
class Single_Dog
{
public:
	
	//必须加static,因为不能创建Single_Dog,加了static才能直接使用这个函数
	static Single_Dog * getInstance()
	{
		return instance;
	}

	void test()
	{
		cout <<" test " << endl;
	}

private:

     //静态变量需要在类外初始化,如果在类内初始化需要加const
	//因为静态成员属于整个类，而不属于某个对象，如果在类内初始化，
	//会导致每个对象去初始化该静态成员，这是矛盾的。
	//加了const,编译器就不会试图去再次初始化,不过一般是在类外初始化
	static Single_Dog* instance;
	Single_Dog(){}
};

Single_Dog*Single_Dog::instance = new Single_Dog;

//懒汉式
class Single_Dog2
{
public:

	//在使用的时候才创建对象
	static Single_Dog2 * getInstance()
	{
		if (instance==nullptr)
		{
			instance = new Single_Dog2;
		}
		return instance;
	}
private:
	static Single_Dog2* instance;
	Single_Dog2(){}
};


Single_Dog2*Single_Dog2::instance = nullptr;

int main()
{
	Single_Dog *sd1 = Single_Dog::getInstance();
	Single_Dog *sd2 = Single_Dog::getInstance();
	if (sd1==sd2)
	{
		sd1->test();
	}

	Single_Dog2 *sd3 = Single_Dog2::getInstance();
	Single_Dog2 *sd4 = Single_Dog2::getInstance();
	if (sd3 == sd4)
	{
		cout << "equals" << endl;
	}

}

4 饿汉和懒汉式的区别

  (1)懒汉式因为不是立刻创建实例,所以一定程度上节省了内存

(2)但是懒汉式多了判断条件,在多线程的情况下是很危险的

(3)饿汉是线程安全的,但是会浪费一定的内存