【设计模式】单例模式

😉废话不多说，直接上代码，看注释就行了

#include <iostream>

using namespace std;

class SingleDemon
{
public:
	//3.类内的public对外提供构造函数的接口
	//创建一个返回值为一个对象的地址，在函数体内进行创建
	//加静态，因为静态的成员对象只能调用静态的成员方法
	static SingleDemon* Create()
	{
		if (s == NULL)
		{
			s = new SingleDemon();
		}
		return s;
	}


private:
	//1.将该类的构造函数放在private
	SingleDemon()
	{
		cout <<"构造" <<endl;
	}

	//2.定义一个该类的一个指针, 为了只创建一个，加上static
	static SingleDemon* s;
};

//4.类外对该对象指针进行初始化
SingleDemon* SingleDemon::s = NULL;


int main()
{
	//5.主函数中实例化对象；调用类的接口
	SingleDemon* p = SingleDemon::Create();
	SingleDemon* q = SingleDemon::Create();

	//以上创建的两个对象其实是一个对象；
	system("pause");

	return 0;
}

可以从地址看出是同一块地址空间；😁

总结：

构建单例：

1.将该类的构造方法放在private中。（让该在类外不能随意使用类名+对象名进行构造）

2.在private中定义一个该类的对象的静态指针。

3.在类内的public中创建一个对外的接口用来调用构造函数，即静态的成员函数。（由于2中的静态指针只能调用静态的成员方法）

4.在类外对private中的静态成员对象指针进行初始化，即置空。（能类外进行初始化，是因为该成员变量加了static）

使用：

类名 *对象名 = 类名::静态成员函数;

SingleDemon* p = SingleDemon::Create();

拓展：

考虑到线程安全，这里使用互斥锁进行保护，保证多个线程进行时，只能有一个线程能调用下列语句创建单例

s = new SingleDemon();

添加mutex头文件；

#include <mutex>

定义一个名为mtx的锁；

std::mutex mtx;

使用加锁、解锁，该方法必须成对出现；

mtx.lock();
mtx.unlock();

完整代码

#include <iostream>
#include <mutex>

using namespace std;

std::mutex mtx;

class SingleDemon
{
public:
	//3.类内的public对外提供构造函数的接口
	//创建一个返回值为一个对象的地址，在函数体内进行创建
	//加静态，因为静态的成员对象只能调用静态的成员方法
	static SingleDemon* Create()
	{
		if (s == NULL)
		{
			mtx.lock();
			if (s == NULL)
			{
				s = new SingleDemon();
			}
			mtx.unlock();
		}
		return s;
	}


private:
	//1.将该类的构造函数放在private
	SingleDemon()
	{
		cout <<"构造" <<endl;
	}

	//2.定义一个该类的一个指针, 为了只创建一个，加上static
	static SingleDemon* s;
};

//4.类外对该对象指针进行初始化,加了静态后
SingleDemon* SingleDemon::s = NULL;


int main()
{
	//5.主函数中实例化对象；调用类的接口
	SingleDemon* p = SingleDemon::Create();
	SingleDemon* q = SingleDemon::Create();

	//以上创建的两个对象其实是一个对象；
	system("pause");

	return 0;
}