【C++】特殊类设计 | 单例设计模式

malloc不出对象2024-05-27 10:48

目录

前言

本篇文章我们重点要讲解的内容为单例模式，单例模式有什么特点？有什么好处？下面就让我们一起进入学习吧！！

一、设计一个类，不能被拷贝

拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。

C++ 98 的做法是将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。

c 复制代码 
class CopyBan
{
	// ...
private:
	CopyBan(const CopyBan&);
	CopyBan& operator=(const CopyBan&);
	//...
};

原因：

1.设置成私有：如果只声明没有设置成 private，用户自己如果在类外定义了，就可以不能禁止拷贝了。

2.只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

C++11 的做法是C++11 扩展了 delete 的用法，delete 除了释放 new 申请的资源外，如果在默认成员函数后跟上 = delete，表示让编译器删除掉该默认成员函数。

c 复制代码 
class CopyBan
{
	// ...
	CopyBan(const CopyBan&) = delete;
	CopyBan& operator=(const CopyBan&) = delete;
	//...
};

二、设计一个只能在堆上创建对象的类

实现方式：

  • 思路一：将类的构造函数私有和拷贝构造声明成私有，防止别人调用拷贝在栈上生成对象。提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。

  • 思路二：将类的析构函数私有，提供一个释放资源的接口即可。因为对象出了作用域，会调用对象的析构函数来完成资源的释放，而在栈区或者静态区上创建的对象无法调用析构函数，但是在堆上创建的对象提供了释放资源的接口来完成资源的释放。

思路一代码：

c 复制代码 
class HeapOnly
{
public:
	static HeapOnly* CreateObject()
	{
		return new HeapOnly;   
	}

	HeapOnly(const HeapOnly& hp) = delete;
	HeapOnly operator=(const HeapOnly& hp) = delete;
	
private:
	HeapOnly()
	{}

	int _x = 0;
};

int main()
{
	HeapOnly* hp = HeapOnly::CreateObject();
	delete hp;

	/*HeapOnly a1;
	static HeapOnly a2;
	HeapOnly copy(*hp);*/

	return 0;
}

思路二代码：

c 复制代码 
class HeapOnly
{
public:
	HeapOnly()
	{}

	static void Delete1(HeapOnly* p)
	{
		delete p;
	}

	void Delete2()
	{
		delete this;
	}

	HeapOnly(const HeapOnly& hp) = delete;
	HeapOnly operator=(const HeapOnly& hp) = delete;

private:
	~HeapOnly()
	{}

	int _x = 0;
};

int main()
{
	HeapOnly* p = new HeapOnly;
	HeapOnly::Delete1(p);  // 静态成员函数

	HeapOnly* s = new HeapOnly;
	s->Delete2();   // 普通成员函数

	//HeapOnly copy(*s);  // 
	//HeapOnly s;

	return 0;
}

三、设计一个只能在栈上创建对象的类

思路：与上述方法相同，我们将构造函数私有化，提供一个静态成员函数来返回匿名对象，但其实我们返回的不是匿名对象而是匿名对象的临时拷贝变量，因此我们需要提供拷贝构造，提供了拷贝构造那么就不能限制对象在栈区/静态区上进行拷贝构造了，不能在堆上创建对象我们可以通过删除operator new 函数来实现。

c 复制代码 
class StackOnly
{
public:
	static StackOnly CreateObject()
	{
		return StackOnly();
	}

	//	// 不能防拷贝
	//	StackOnly(const StackOnly& hp) = delete;
	//	StackOnly& operator=(const StackOnly& hp) = delete;
	
	// 限制在堆上创建对象
	void* operator new(size_t n) = delete;

private:
	StackOnly()
	{}

	int _x = 0;
};

int main()
{
	StackOnly s = StackOnly::CreateObject();
	static StackOnly copy(s);

	// StackOnly ps* = new StackOnly;   
	//static StackOnly ps = new StackOnly;

	return 0;
}

四、设计一个类，不能被继承

C++98 的做法是将构造函数私有化，派生类中调不到基类的构造函数，则无法继承。

c 复制代码 
class NonInherit
{
public:
	static NonInherit GetInstance()
	{
		return NonInherit();
	}
private:
	NonInherit()
	{}
};

而 C++ 11 的做法是 final 关键字修饰类，表示该类不能被继承。

c 复制代码 
class A final
{
	// ....
};

五、设计一个类，只能创建一个对象(单例模式)

设计模式 ：设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。

使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

单例模式： 一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。

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

5.1 饿汉模式

不管你将来用不用，程序启动时就创建一个唯一的实例对象，在进入main函数之前就已经实例化出一个对象。

整体思路：

  1. 把数据放进一个类里面，将这个类设计成单例类
  2. 把构造函数私有化，防止其随意创建对象，提供一个静态成员函数来返回单例对象
  3. 根据性质设计为饿汉或懒汉模式

饿汉模式的简化代码如下：

c 复制代码 
class Singleton 
{
public:
	static Singleton* GetInstance()
	{
		return _ins;   // 每次返回的对象都是指向同一块空间的
	}
	
	// 插入数据需要保证线程安全问题
	void Add(const string& str)
	{
		_mtx.lock();
		_v.emplace_back(str);
		_mtx.unlock();
	}

	void Print()
	{
		_mtx.lock();

		for (auto& e : _v)
		{
			cout << e << endl;
		}
		cout << endl;

		_mtx.unlock();
	}

private:
	Singleton()  // 构造函数私有化，不能随意创建对象
	{}

	mutex _mtx;
	vector<string> _v;
	static Singleton* _ins;
};

Singleton* Singleton::_ins = new Singleton;    // 在未进入main函数之前就已经实例化出来了

int main()
{
	srand(time(0));
	int n = 100;

	thread t1([n]() {
		for (size_t i = 0; i < n; i++)
		{
			Singleton::GetInstance()->Add("t1线程，第" + to_string(i) + "个" + to_string(rand()));
		}
		});

	thread t2([n]() {
		for (size_t i = 0; i < n; i++)
		{
			Singleton::GetInstance()->Add("t2线程，第" + to_string(i) + "个" + to_string(rand()));
		}
		});

	t1.join();
	t2.join();

	Singleton::GetInstance()->Print();

	return 0;
}

如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好。

5.2 懒汉模式

如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好。

懒汉模式的简化代码：

c 复制代码 
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		// 这里的判断是为了提高效率，假设对象已经创建出来了，那么我们就直接返回原来的对象即可
		if (_ins == nullptr)  
		{
			_imtx.lock();
		// 这里的判断是为了保证线程安全，假设没有这个条件判断，当t1获得锁然后new一个对象后解锁，此时t1时间片到了，t2获得了锁，如果此时不加判断的话那么就会覆盖掉t1 new的对象
			if (_ins == nullptr) 
			{
				_ins = new Singleton;
			}
			_imtx.unlock();
		}

		return _ins;
	}

	void Add(const string& str)
	{
		_mtx.lock();
		_v.emplace_back(str);
		_mtx.unlock();
	}
		
	void Print()
	{
		_mtx.lock();
		
		for (auto& e : _v)
		{
			cout << e << endl;
		}
		cout << endl;

		_mtx.unlock();
	}

	static void DelInstance()
	{
		_imtx.lock();
		if (_ins)
		{
			delete _ins;
			_ins = nullptr;
		}
		_imtx.unlock();
	}

	// 单例对象回收 ------ Singleton析构之前先析构成员变量GC的资源，GC析构又会调用DelInstance隐式回收单例对象
	class GC
	{
	public:
		~GC()
		{
			DelInstance();
		}
	};

private:
	Singleton()
	{}

	mutex _mtx;
	vector<string> _v;
	static Singleton* _ins;
	static mutex _imtx;
	static GC _gc;
};

mutex Singleton::_imtx;    // 非对象成员函数中需要添加同一把锁来保证线程安全
Singleton* Singleton::_ins = nullptr;
Singleton::GC Singleton::_gc;

int main()
{
	srand(time(0));
	int n = 100;

	thread t1([n]() {
		for (size_t i = 0; i < n; i++)
		{
			Singleton::GetInstance()->Add("t1线程，第" + to_string(i) + "个" + to_string(rand()));
		}
		});

	thread t2([n]() {
		for (size_t i = 0; i < n; i++)
		{
			Singleton::GetInstance()->Add("t2线程，第" + to_string(i) + "个" + to_string(rand()));
		}
		});

	t1.join();
	t2.join();

	Singleton::GetInstance()->Print();

	return 0;
}

5.3 饿汉模式VS懒汉模式

饿汉模式

  • 优点：简单(相较懒汉模式)。
  • 缺点：一个程序中有多个单例，并且有先后创建初始化顺序要求时，饿汉模式无法控制单例对象初始化的先后顺序；饿汉单例类对象初始化时任务多，会影响程序启动速度，并且当暂时用不到时却占用了资源！！

懒汉模式

  • 优点： 多个单例实例启动顺序可以自由控制；当需要时才将资源加载到程序中来，不影响启动速度。
  • 缺点：相对复杂，需要处理好线程安全问题。

单例对象的释放问题

一般情况下，单例对象是不需要释放的。因为整个程序运行期间都可能使用它，单例对象在进程正常结束后，也会释放资源。

有些特殊场景需要释放，比如：单例对象析构时，要进行一些持久化（往文件、数据库写数据等）操作。

相关推荐
‘’林花谢了春红‘’5 小时前
C++ list （链表）容器
c++·链表·list
机器视觉知识推荐、就业指导6 小时前
C++设计模式：建造者模式（Builder） 房屋建造案例
c++
Yang.998 小时前
基于Windows系统用C++做一个点名工具
c++·windows·sql·visual studio code·sqlite3
熬夜学编程的小王8 小时前
【初阶数据结构篇】双向链表的实现（赋源码）
数据结构·c++·链表·双向链表
zz40_8 小时前
C++自己写类 和 运算符重载函数
c++
六月的翅膀8 小时前
C++：实例访问静态成员函数和类访问静态成员函数有什么区别
开发语言·c++
liujjjiyun9 小时前
小R的随机播放顺序
数据结构·c++·算法
￥ 多多￥9 小时前
c++中mystring运算符重载
开发语言·c++·算法
天若有情67310 小时前
c++框架设计展示---提高开发效率！
java·c++·算法
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作