【初阶与进阶C++详解】第二十六篇：特殊类设计（单例模式）

🏆个人主页：企鹅不叫的博客

​ 🌈专栏

• C语言初阶和进阶
• C项目
• Leetcode刷题
• 初阶数据结构与算法
• C++初阶和进阶
• 《深入理解计算机操作系统》
• 《高质量C/C++编程》
• Linux

⭐️ 博主码云gitee链接：代码仓库地址

⚡若有帮助可以【关注+点赞+收藏】，大家一起进步！

💙系列文章💙

【初阶与进阶C++详解】第一篇：C++入门知识必备

【初阶与进阶C++详解】第二篇：C&&C++互相调用（创建静态库）并保护加密源文件

【初阶与进阶C++详解】第三篇：类和对象上（类和this指针）

【初阶与进阶C++详解】第四篇：类和对象中（类的六个默认成员函数）

【初阶与进阶C++详解】第五篇：类和对象下（构造+static+友元+内部类

【初阶与进阶C++详解】第六篇：C&C++内存管理（动态内存分布+内存管理+new&delete）

【初阶与进阶C++详解】第七篇：模板初阶（泛型编程+函数模板+类模板+模板特化+模板分离编译）

【初阶与进阶C++详解】第八篇：string类（标准库string类+string类模拟实现）

【初阶与进阶C++详解】第九篇：vector(vector接口介绍+vector模拟实现+vector迭代器区间构造/拷贝构造/赋值)

【初阶与进阶C++详解】第十篇：list(list接口介绍和使用+list模拟实现+反向迭代器和迭代器适配)

【初阶与进阶C++详解】第十一篇：stack+queue+priority_queue+deque（仿函数）

【初阶与进阶C++详解】第十二篇：模板进阶(函数模板特化+类模板特化+模板分离编译)

【初阶与进阶C++详解】第十三篇：继承(菱形继承+菱形虚拟继承+组合)

【初阶与进阶C++详解】第十四篇：多态（虚函数+重写（覆盖）+抽象类+单继承和多继承）

【初阶与进阶C++详解】第十五篇：二叉树搜索树（操作+实现+应用KVL+性能+习题）

【初阶与进阶C++详解】第十六篇：AVL树-平衡搜索二叉树（定义+插入+旋转+验证）

【初阶与进阶C++详解】第十七篇：红黑树（插入+验证+查找）

【初阶与进阶C++详解】第十八篇：map_set（map_set使用+multiset_multimap使用+模拟map_set）

【初阶与进阶C++详解】第十九篇：哈希（哈希函数+哈希冲突+哈希表+哈希桶）

【初阶与进阶C++详解】第二十篇：unordered_map和unordered_set（接口使用+模拟实现）

【初阶与进阶C++详解】第二十一篇：哈希应用（位图实现应用+布隆过滤器增删查优缺点+海量数据面试题）

【初阶与进阶C++详解】第二十二篇：C++11新特性（列表初始化+变量类型推到+右值引用+新增默认成员函数+可变模板参数+lambda表达式+包装器function_bind）

【初阶与进阶C++详解】第二十三篇：异常（异常抛出+异常捕获+异常优缺点）

【初阶与进阶C++详解】第二十四篇：智能指针（内存泄漏+RAII+auto_ptr+unique_ptr+shared_ptr+weak_ptr+定制删除器）

【初阶与进阶C++详解】第二十五篇：类型转换（static_cast+reinterpret_cast+const_cast+dynamic_cast+RTTI）

---

---

💎一、设计模式

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

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

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

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

class CopyBan
{
	 // ...

private:
	 CopyBan(const CopyBan&);
	 CopyBan& operator=(const CopyBan&);
	 //...
};

原因：

1. 设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了
2. 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

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

class CopyBan
{
	 // ...
	 CopyBan(const CopyBan&)=delete;
	 CopyBan& operator=(const CopyBan&)=delete;
	 //...
};

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

C++98：构造函数私有化，派生类中调不到基类的构造函数（派生类的构造函数，必须调用父类的构造函数初始化继承的父类成员，但是父类构造函数私有，派生类内不可见），则无法继承

// C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:
	static NonInherit GetInstance()
	 {
		return NonInherit();
	 }
private:
	 NonInherit()
	{}
};

C++11：final关键字，final修饰类，表示该类不能被继承。

class A final
{
	 // ....
};

💎四、设计一个类，只能在堆上创建对象

实现方式：

1. 将类的构造函数私有，这样就无法在栈或堆上直接定义对象了。
2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建(因为，构造函数私有，在外面不能调动，就需要成员函数去调动，而成员函数需要成员调动，但是不能创建成员，因此用一个静态函数去调用构造函数)。
3. 创建出来的对象虽然是在堆上的，但是由于拷贝函数的存在，可能会拷贝到栈上，因此将拷贝构造声明为私有的且不实现，或者直接删除掉。

class HeapOnly
{
public:
	static HeapOnly* CreateObject()
	{
		return new HeapOnly;
	}
private:
	HeapOnly()   
    {}

	// C++98
	// 1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要
	// 2.声明成私有
	HeapOnly(const HeapOnly&);

		// or

		// C++11 
	HeapOnly(const HeapOnly&) = delete;//直接删除
};

💎五、设计一个类，只能在栈上创建对象

同上将构造函数私有化，然后设计静态方法创建对象返回即可。

class StackOnly 
{ 
public: 
	 static StackOnly CreateObject() 
	 { 
		return StackOnly(); //构造一个匿名对象，拷贝返回即可
	 }
private:
	 StackOnly() {}
};

💎六、设计一个类，只能创建一个对象（单例模式）

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

🏆1.饿汉模式

就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。

class Singleton
{
public:
	//提供一个共有接口，来获取这个对象
	static Singleton* GetInstance()
	{
		return _psln;
	}
private:
 // 构造函数私有
	Singleton()
	{}
 // C++11
	Singleton(const Singleton&) = delete;
	Singleton& operator=(Singleton&) = delete;
	//在private中创建一个static对象(声明)，这个对象不属于这个类，是全局对象，但要受到这个域的限制
	static Singleton* _psln;//声明
};
// static对象在main函数之前创建，此时只有主线程，所以不存在线程安全的问题
Singleton Singleton::_psln = new Singleton;//定义

饿汉模式的特点:

• 构造函数私有

• 提供一个静态的方法返回单例

• 声明一个静态的单例成员

• 拷贝构造和赋值声明为delete函数

  饿汉模式的优缺点:

• 优点：实现简单、多线程场景下效率高。

• 缺点：程序启动慢、多个单例的初始化顺序是无法控制的。

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

🏆2.懒汉模式

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

class InfoMgr
{
public:
	static InfoMgr* GetInstance()
	{
		// 还需要加锁，这个后面讲  -- 双检查加锁
		if (_spInst == nullptr)
		{
			_spInst = new InfoMgr;
		}

		return _spInst;
	}

	void SetAddress(const string& s)
	{
		_address = s;
	}

	string& GetAddress()
	{
		return _address;
	}

	// 实现一个内嵌垃圾回收类    
	class CGarbo //程序结束了，资源自然会还给系统，可写可不可
{
	public:
		~CGarbo(){
			if (_spInst)
				delete _spInst;
		}
	};

	// 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
	static CGarbo Garbo;

private:
	InfoMgr()
	{}

	~InfoMgr()
	{
		// 假设析构时需要信息写到文件持久化
	}
	//拷贝、赋值需要禁掉
	InfoMgr(const InfoMgr&) = delete;
 InfoMgr& operator=(InfoMgr&) = delete;

	string _address;
	int _secretKey;
	// 声明一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
	static InfoMgr* _spInst; // 声明
};

InfoMgr* InfoMgr::_spInst = nullptr; //初始化为空
InfoMgr::CGarbo Garbo;//初始化

懒汉模式的特点:

• 构造函数私有

• 提供一个静态的方法返回单例，第一次调用创建对象，后续调用直接返回

• 声明一个静态的单例成员指针，指针初始化为空

• 拷贝构造和赋值声明为delete函数

• 保证线程安全(修改指针)，双检查提高效率

  懒汉模式的优缺点:

• 优点：延迟加载，启动快。可以指定多个单例对象的初始化顺序。

• 缺点：实现复杂一点。

🏆2.饿汉模式和懒汉模式区别

1. 懒汉模式需要考虑线程安全和释放的问题，实现相对复杂；饿汉模式不存在这个问题，实现起来简单。
2. 懒汉模式是一种懒加载模式，需要时再初始化创建对象，不会影响程序的启动。饿汉模式则相反，程序启动阶段就初始化实例对象，会导致程序启动慢，影响体验。
3. 如果有多个单例类，假设有依赖关系（B依赖A），要求A单例先创建初始化，B单例再创建初始化，就不能用饿汉模式，因为无法保证初始化顺序。
4. 实际中懒汉模式还是更实用一些。

---