当前位置：首页 > article >正文

C++练级计划-＞《单例模式》懒汉和饿汉

article 2025/2/22 2:09:15

单例模式是什么？

单例模式的应用：

饿汉单例模式：

1.实现：

2.理解：

懒汉单例模式：

1.实现：

2.理解：

懒汉和饿汉的优缺点

饿汉模式的优点：

饿汉模式的缺点：

懒汉模式的优点：

懒汉模式的缺点：

单例模式是什么？

单例模式顾名思义：单个实例，就是说一个类只能实例化出一个对象。通常都是作为全局对象，要让所有人都能访问，但是只有一份。

单例模式的应用：

日志记录：通常在开发过程中是多人的，那就会有很多人来写日志。这时候就需要一个日志记录器，用于记录所有模块的日志信息，所以这个记录器应该是针对所有人的，并且为了避免重复，所以使用单例模式

相似的还有配置管理，连接池管理，全局状态管理

在多线程下的线程安全对象。有些对象需要确保只有一个实例被多个线程共享（多个线程使用一个对象）。结合锁的使用，可以保证这个单独对象在多线程下的安全性和一致性。

饿汉单例模式：

1.实现：

单例模式的使用方式就是：这个对象初始化完后，只能通过一个静态接口获取，并且要把构造函数和赋值构造拷贝构造都放入私有中。如下代码：

class Singleton
	{
	public:
		static Singleton* GetInstance() //通过调用GetInstance() 在类外获得实例
		{	
			return &_slt;                //返回这个实例的地址
		}
 
		void print()                   //输出实例的数据
		{
			cout << _x << " " << _y << endl;
			for (auto e : _vect)
			{
				cout << e << " ";
			}
			cout << endl;
		}
 
		void Add_Vect(int n)         //对实例的Vector进行尾插
		{
			_vect.push_back(n);
		}
 
	private:
		int _x;
		int _y;
		vector<int>_vect;
		static Singleton _slt; //类内声明
		//因为要实现单例类（全局只能有一个对象，因此要将构造函数私有化否则可以在类外随便创建）
		Singleton(int x = 1, int y = 1, const vector<int>& v = { 1,2,3,4,5 })
			:_x(x)
			, _y(y)
			, _vect(v)
		{}
		//禁用拷贝构造和赋值重载
		Singleton(const Singleton& hs) = delete;
		Singleton& operator=(const Singleton& hs) = delete;
	};
 
	//类外初始化
	Singleton Singleton::_slt(2, 2,{ 4,5,6 });
 
	//测试懒汉
	void Test01()
	{
		//Singleton::GetInstance()返回创建静态对象的指针
		Singleton::GetInstance()->print();
		Singleton::GetInstance()->print();
		cout << "对象1的地址为：" << Singleton::GetInstance() << endl;
		cout << "对象2的地址为：" << Singleton::GetInstance() << endl;
		//结果为：
		//2 2 
		//4 5 6
		//后面两个地址是一样的（也就是返回的都是同一个实例）
	}

2.理解：

1.饿汉模式解释：

顾名思义：饿汉，就是一个很饿的人，只要有东西吃立马就吃了，没有任何等待的所以饿汉模式就是在还没进入main函数前就实例好的模式。

2.为什么要把三种构造函数私有化？

很显然我们要实现单例，那就不允许你在类外调用构造函数，生成这个对象，所以我们在类内就声明了这个对象，初始化时也是只能对这个对象(_slt)初始化。拷贝和赋值也是同理，我只能有一个这个对象，所以不允许你拷贝和赋值

3.然后实现的饿汉模式（对上面代码的解释）

static Singleton _slt; //类内声明
我们在类内声明了这个对象，然后把三个构造函数给私有化，所以现在就只剩下这一个对象

又因为单例模式是全局给所有人使用的所以在类外初始化时是全局初始化
//类外初始化
	Singleton Singleton::_slt(2, 2,{ 4,5,6 });
接下来要调用这个对象，只能通过先指定要调用的类然后GetInstance()找到这个单例对象。然后才能调用对应的接口。因为无法构造，且调用时只能通过接口，所以不用担心对象被修改。所以实现了单例模式
static Singleton* GetInstance() //通过调用GetInstance() 在类外获得实例
        {    
            return &_slt;                //返回这个实例的地址
        }
//Singleton::GetInstance()返回创建静态对象的指针
		Singleton::GetInstance()->print();
		Singleton::GetInstance()->print();

懒汉单例模式：

顾名思义：懒汉，就是很懒的一个人，顶级拖延症，只有必要时才会做对应的事，所以懒汉就是只有要使用这个实例时才进行创建

1.实现：

class Singleton
	{
	public:
		static Singleton* GetInstance() //必须定义为静态函数因为只有这样才可以不创建对象去调用它来创建对象
		{								//否则所有成员函数要通过对象去调用(若不设置为静态的无法创建出来对象（构造函数私有了）)
			static Singleton slt(2, 2, {7,8,9});		//静态函数每次只会初始化一次 所以只会在第一次调用时初始化
			return &slt;                //下次调用GetInstance()会直接返回&slt
		}
		void print()
		{
			cout << _x << " " << _y << endl;
			for (auto e : _vect)
			{
				cout << e << " ";
			}
			cout << endl;
		}
		void Add_Vect(int n)
		{
			_vect.push_back(n);
		}
 
	private:
		int _x;
		int _y;
		vector<int>_vect;
		//因为要实现单例类（全局只能有一个对象，因此要将构造函数私有化否则可以在类外随便创建）
		Singleton(int x = 1, int y = 1, const vector<int>& v = { 1,2,3,4,5 })
			:_x(x)
			, _y(y)
			, _vect(v)
		{}
		//禁用拷贝构造和赋值重载
		Singleton(const Singleton& hs) = delete;
		Singleton& operator=(const Singleton& hs) = delete;
	};
 
	//测试懒汉
	void Test01()
	{
		//Singleton::GetInstance()返回创建静态对象的指针
		Singleton::GetInstance()->print();    
		Singleton::GetInstance()->print();
		cout << "对象1的地址为：" << Singleton::GetInstance() << endl;
		cout << "对象2的地址为：" << Singleton::GetInstance() << endl;
		//结果为：(因为调用两次所以打印两次)
		//2 2 
		//7 8 9
		//2 2
		//7 8 9
		//后面两个地址是一样的
	}