• 【C++】特殊类的设计(单例模式为主)(学习复习兼顾)

    ꧁ 大家好，我是 兔7 ，一位努力学习C++的博主~ ꧂

    ☙ 如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步❧

    🚀 如有不懂，可以随时向我提问，我会全力讲解~💬

    🔥 如果感觉博主的文章还不错的话，希望大家关注、点赞、收藏三连支持一下博主哦~！👀

    🔥 你们的支持是我创作的动力！⛅

    🧸 我相信现在的努力的艰辛，都是为以后的美好最好的见证！⭐

    🧸 人的心态决定姿态！⭐

    🚀 本文章CSDN首发！✍

    目录

    0. 前言

    1. 设计一个类，只能在堆上创建对象

    ​编辑

    2. 设计一个类，只能在栈上创建对象

    方法一： 同上

    方法二：屏蔽new

    3. 设计一个类，不能被拷贝

    4. 设计一个类，不能被继承

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

    设计模式：

    单例模式：

    单例模式有两种实现模式：

    懒汉模式和饿汉模式的对比

    饿汉

    懒汉

    0. 前言

            此博客为博主以后复习的资料，所以大家放心学习，总结的很全面，每段代码都给大家发了出来，大家如果有疑问可以尝试去调试。

            大家一定要认真看图，图里的文字都是精华，好多的细节都在图中展示、写出来了，所以大家一定要仔细哦~

            感谢大家对我的支持，感谢大家的喜欢， 兔7 祝大家在学习的路上一路顺利，生活的路上顺心顺意~！

    1. 设计一个类，只能在堆上创建对象

    实现方式：

    1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
    2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。
    1. class HeapOnly
    2. {
    3. public:
    4. 	static HeapOnly* CreateObj()
    5. 	{
    6. 		return new HeapOnly;
    7. 	}
    8.  
    9. 	HeapOnly(const HeapOnly&) = delete;
    10.  
    11. private:
    12. 	HeapOnly()
    13. 	{}
    14. 	//HeapOnly(const HeapOnly&);
    15. };
    16.  
    17. //HeapOnly::HeapOnly(const HeapOnly&)
    18. //{}
    19.  
    20. int main()
    21. {
    22. 	//HeapOnly ho;
    23. 	//HeapOnly* p = new HeapOnly;
    24. 	HeapOnly* p = HeapOnly::CreateObj();
    25. 	HeapOnly copy(*p);
    26.  
    27. 	return 0;
    28. }

            我们可以看到，我们这里将构造函数放到 private 里面，那么类外面就不能调用构造函数，也就不能创建对象了，所以我们要想办法在类里设置一个接口可以调用构造函数，但是这个接口必须要是 static 的，因为如果不是静态的，那么类外必须要用实例化好的对象去调用，但是我们又不能在类外创建对象，我们调用这个接口就是为了创建对象。

            所以这里就有了一个问题，那么这时就要设置为静态的，这样外面直接就可以调用这个接口在堆上创建对象了。

             但是我们可以看到，虽然我们将构造函数设为私有不可以直接创建对象了，但是还是可以通过拷贝构造函数去在栈上创建对象！

            所以还是老套路嘛，直接将拷贝构造在私有里声明一下就可以了。

    当然这里为什么直接声明一下就可以了呢？

            是因为我们没有必要去实现，因为也没有人去用它，所以就实现可以，不实现也是可以的。

    那构造函数是需要实现的，不能够只声明又是为什么呢？

            这是因为我们要用构造函数在堆上去创建对象，简单来说就是我们上面的 CreateObj 里要去使用这个构造函数。

            虽然这个拷贝构造虽然没有实现，只是声明了一下，但是还是要将拷贝构造放到私有里面，原因：

            就有人有可能会在类外去定义，那么拷贝构造就又可以使用了，所以做事做绝，直接在私有里去声明就可以了。

            这个方法在 C++98 里叫做防拷贝。

            在 C++11 中还有一种方法，就是用关键字 delete 。

            我们可以看到，这个函数已经被删除了，所以不可以去调用了。而且如果我们将它放到公有里面，还是不可以使用的：

            可以看到，是同样的效果。

    2. 设计一个类，只能在栈上创建对象

    方法一： 同上

    1. class StackOnly
    2. {
    3. public:
    4. 	static StackOnly CreateObject()
    5. 	{
    6. 		return StackOnly();
    7. 	}
    8. private:
    9. 	StackOnly()
    10. 	{}
    11. };

             还是和上面相同的做法，但是这里就不能禁用拷贝构造了，因为在返回的时候肯定是返回一个局部对象，所以 CreateObject 只能传值返回，但是只要是传值返回就肯定是要拷贝构造，那么如果把拷贝构造禁用了，那么返回的时候就会有问题。

    方法二：屏蔽new

            因为new在底层调用void* operator new(size_t size)函数，只需将该函数屏蔽掉即可。

    注意：也要防止定位new 

    1. class StackOnly
    2. {
    3. public:
    4. 	StackOnly() {}
    5. private:
    6. 	void* operator new(size_t size);
    7. 	void operator delete(void* p);
    8. };
    9.  
    10. int main()
    11. {
    12. 	StackOnly so;
    13. 	StackOnly* p = new StackOnly;
    14.  
    15. 	static StackOnly sso;
    16. 	return 0;
    17. }

            这里是因为 new 的时候是由两部分构成，第一部分是申请空间调用 operator new ，默认是调用全局的 operator new，再调它的构造函数。但是一个类可以重载专属的 operator new，所以这时肯定就会调用专属的  operator new ，所以我们将 operator new 设为私有，那么这时就调用不动了。

             当然也可以用 C++11 的方法去实现。

            但是这个方法有缺陷，虽然可以在栈上创建对象，不能在堆上创建对象了，但是：

            但是可以在静态区去创建对象，所以这个方法是有一些缺陷的。

    3. 设计一个类，不能被拷贝

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

    • C++98

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

    1. class CopyBan
    2. {
    3. 	// ...
    4.  
    5. private:
    6. 	CopyBan(const CopyBan&);
    7. 	CopyBan& operator=(const CopyBan&);
    8. 	//...
    9. };

    原因：

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

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

    1. class CopyBan
    2. {
    3. 	// ...
    4. 	CopyBan(const CopyBan&) = delete;
    5. 	CopyBan& operator=(const CopyBan&) = delete;
    6. 	//...
    7. };

    4. 设计一个类，不能被继承

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

            无法继承的原因是父类私有成员在子类不可见。

    1. class NonInherit
    2. {
    3. public:
    4. 	static NonInherit GetInstance()
    5. 	{
    6. 		return NonInherit();
    7. 	}
    8. private:
    9. 	NonInherit()
    10. 	{}
    11. };

            也就是说子类的构造函数想要初始化父类的那一部分，不能自己去对那一部分去初始化，而是要调用父类的构造函数去初始化，所以我们只要将父类的构造函数设为私有的，那么子类就看不到父类的构造函数，也就无法对其初始化，也就不能够被继承。

            但是这里其实还是不够彻底的：

            我们可以看到，其实是可以继承的，但是这里真正限制的是：

            也就是子类继承后不能实例化出对象来，但是其实不能实例化出对象来，这个类就费了一半了，因为我们在使用类的时候基本都是实例化出对象，然后通过对象去进行一番操作。

            但这也是不彻底的，所以才有了 C++11 的一个关键字 final。

    • C++11方法

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

            C++11 为了更直观彻底的实现不能被继承，增加了关键字 final。 

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

            在设计单例模式的时候会用到多线程的知识，我已经写过关于多线程的特特特详细博客了，下面就是链接，大家可以去看一看，多线程是非常重要的！

    多线程(重中之重)

    设计模式：

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

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

    单例模式：

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

    单例模式有两种实现模式：

    • 饿汉模式

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

    1. // 饿汉模式
    2. // 优点：简单
    3. // 缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。
    4. class Singleton
    5. {
    6. public:
    7. 	static Singleton* GetInstance()
    8. 	{
    9. 		return m_instance;
    10. 	}
    11.  
    12. private:
    13. 	// 构造函数私有
    14. 	Singleton() 
    15. 	{};
    16.  
    17. 	// C++98 防拷贝
    18. 	Singleton(Singleton const&);
    19. 	Singleton& operator=(Singleton const&);
    20.  
    21. 	// or
    22.  
    23. 	// C++11
    24. 	Singleton(Singleton const&) = delete;
    25. 	Singleton& operator=(Singleton const&) = delete;
    26.  
    27. 	static Singleton* m_instance;
    28. };
    29. // 在程序入口之前就完成单例对象的初始化
    30. Singleton* Singleton::m_instance = new Singleton; 
    31.  
    32. int main()
    33. {
    34. 	cout << Singleton::GetInstance() << endl;
    35. 	cout << Singleton::GetInstance() << endl;
    36. 	cout << Singleton::GetInstance() << endl;
    37. 	return 0;
    38. }

            在自己类里不能定义自己的类型，但是自己类里定义自己类的指针是可以的，而且要定义成静态的，因为 GetInstance 也是静态的，因为静态的函数只能调用静态的成员函数。

            然后因为是定义的静态的成员函数，所以需要在类外去初始化。

            这个静态成员是在调用 main 函数之前就实例化了的。

            然后我们可以通过在 main 函数中调用 GetInstance ，而且可以看到地址是一样的，也就是说这个进程只为这个类实例化了一个对象。

            但是饿汉模式的缺点也很严重，就是如果这个项目的初始化很多，比如说加载数据库之类的配置初始化工作，那么这个配置初始化工作就要有很长时间，那么饿汉就很不合适了，因为启动进程非常慢。

    • 懒汉模式
    1. // 懒汉
    2. // 优点：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控制。
    3. // 缺点：复杂
    4. #include 
    5. #include 
    6. #include 
    7. using namespace std;
    8. class Singleton
    9. {
    10. public:
    11. 	static Singleton* GetInstance() {
    12. 		// 注意这里一定要使用Double-Check的方式加锁，才能保证效率和线程安全
    13. 		if (nullptr == m_pInstance) {
    14. 			m_mtx.lock();
    15. 			if (nullptr == m_pInstance) {
    16. 				m_pInstance = new Singleton();
    17. 			}
    18. 			m_mtx.unlock();
    19. 		}
    20. 		return m_pInstance;
    21. 	}
    22. 	// 实现一个内嵌垃圾回收类
    23. 	class CGarbo {
    24. 	public:
    25. 		~CGarbo() {
    26. 			if (Singleton::m_pInstance)
    27. 				delete Singleton::m_pInstance;
    28. 		}
    29. 	};
    30. 	// 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
    31. 	static CGarbo Garbo;
    32. private:
    33. 	// 构造函数私有
    34. 	Singleton() {};
    35. 	// 防拷贝
    36. 	Singleton(Singleton const&);
    37. 	Singleton& operator=(Singleton const&);
    38. 	static Singleton* m_pInstance; // 单例对象指针
    39. 	static mutex m_mtx; //互斥锁
    40. };
    41. Singleton* Singleton::m_pInstance = nullptr;
    42. Singleton::CGarbo Garbo;
    43. mutex Singleton::m_mtx;
    44. void func(int n)
    45. {
    46. 	cout << Singleton::GetInstance() << endl;
    47. }
    48.  
    49. // 多线程环境下演示上面GetInstance()加锁和不加锁的区别。
    50. int main()
    51. {
    52. 	thread t1(func, 10);
    53. 	thread t2(func, 10);
    54. 	t1.join();
    55. 	t2.join();
    56. 	cout << Singleton::GetInstance() << endl;
    57. 	cout << Singleton::GetInstance() << endl;
    58. }

             我们可以看到，我们将静态成员初始化为空，当我们调用 GetInstance 的时候再进行初始化。

            但是这里有一个问题，就是有线程安全的问题。

            就是当多线程的时候，刚进行判断了为 nullptr ，然后进去，还没有调用 new ，然后当前线程就被切走了，然后下一个线程来了还是 nullptr 就又进去 new 了一个对象，然后恢复第一个线程的上下文后又 new 了一个对象，第二个 new 的就将第一个的给覆盖了，所以这样就有错误了！

            所以这里我们就可以使用互斥锁~

            因为加锁要加在一个锁上才有用，所以我们也要将锁设为静态的，然后在类外进行初始化，我们这样就保证了只实例化出一个对象来，但是这样实际上还是有些问题的。

            问题就是当我们 new 出一个对象之后，我们在进行调用 GetInstance 的时候，还会不停的加锁解锁，我们知道，在我之前写的多线程的时候说过，加锁解锁是有性能消耗的，所以不断的加锁解锁是很不好的。

            所以这里我们就要使用双检测加锁：

             这样就减少加锁，获取了效率了。

            那么这里有的小伙伴还是会有一点问题，那么就单例对象什么时候释放。

            其实单例对象是不需要释放的，因为一般情况下单例在进程启动之后随时会被用，而且这个对象也不大，那么就可以不去释放。

            那么会有内存泄漏？其实如果进程是正常结束的，因为 new 出来得到的进程地址空间是虚拟内存，当结束之后就会将地址通过页表取消映射，那么 new 出来的资源就会还给 OS 。

            当然如果想要释放也是没有问题的：

            我们就实现一个 DelInstance 去手动调用的去释放。

            当然有大佬考虑到程序结束时，需要处理一下持久化保存一些数据，比方说要将数据写到硬盘上。那么就可以写一个析构函数，在析构函数中去处理。

            然后如果担心自己会忘记手动调用 DelInstance ，那么就可以通过设计一个类，类中实现一个析构函数。

            这个就是创建的时候创建一个 _gc，当 main 结束的时候 _gc 生命周期结束，然后调用它的析构函数，然后直接将单例对象进行析构。

            下面是我写的整体的代码：

    1. class Singleton
    2. {
    3. public:
    4. 	static Singleton* GetInstance()
    5. 	{
    6. 		if (m_instance == nullptr)
    7. 		{
    8. 			_mtx.lock();
    9. 			if (m_instance == nullptr)
    10. 			{
    11. 				m_instance = new Singleton;
    12. 			}
    13. 			_mtx.unlock();
    14. 		}
    15.  
    16. 		return m_instance;
    17. 	}
    18.  
    19. 	static void DelInstance()
    20. 	{
    21. 		//if (m_instance == nullptr)
    22. 		//{
    23. 			_mtx.lock();
    24. 			if (m_instance == nullptr)
    25. 			{
    26. 				delete m_instance;
    27. 				m_instance = nullptr;
    28. 			}
    29. 			_mtx.unlock();
    30. 		//}
    31. 	}
    32.  
    33. private:
    34. 	Singleton()
    35. 	{};
    36. 	~Singleton()
    37. 	{
    38. 		// 程序结束时，需要处理一下持久化保存一些数据
    39. 	}
    40. 	Singleton(Singleton const&) = delete;
    41. 	Singleton& operator=(Singleton const&) = delete;
    42.  
    43. 	// 实现一个内嵌垃圾回收类
    44. 	class CGarbo {
    45. 	public:
    46. 		~CGarbo()
    47. 		{
    48. 			if (m_instance)
    49. 			{
    50. 				delete m_instance;
    51. 				m_instance = nullptr;
    52. 			}
    53. 		}
    54. 	};
    55. 	static Singleton* m_instance;
    56. 	static std::mutex _mtx;
    57. 	static CGarbo _gc;
    58. };
    59. Singleton* Singleton::m_instance = nullptr;
    60. std::mutex Singleton::_mtx;
    61. Singleton::CGarbo Singleton::_gc;
    62.  
    63. int main()
    64. {
    65. 	cout << Singleton::GetInstance() << endl;
    66. 	cout << Singleton::GetInstance() << endl;
    67. 	cout << Singleton::GetInstance() << endl;
    68. 	return 0;
    69. }

              上面的懒汉是标准的懒汉模式，当然还有大佬更绝，写了一个极致的懒汉：

    1. class Singleton
    2. {
    3. public:
    4. 	static Singleton* GetInstance()
    5. 	{
    6. 		static Singleton m_instance;
    7. 		return &m_instance;
    8. 	}
    9.  
    10. private:
    11. 	Singleton()
    12. 	{};
    13.  
    14. 	Singleton(Singleton const&) = delete;
    15. 	Singleton& operator=(Singleton const&) = delete;
    16.  
    17. 	static Singleton* m_instance;
    18. };
    19.  
    20. int main()
    21. {
    22. 	cout << Singleton::GetInstance() << endl;
    23. 	cout << Singleton::GetInstance() << endl;
    24. 	cout << Singleton::GetInstance() << endl;
    25. 	return 0;
    26. }

             因为局部的静态成员函数初始化是在调用 GetInstance 的时候才会初始化，而且就算是多线程来了也不会有问题，可以认为 static Singleton m_instance; 是原子的。

            如果说缺点，它也是有的，因为这个变量是在静态区的，如果单例对象太大，就不合适了，因为静态区的空间不适合太大的，而在堆上就没事，因为堆上的空间是很大的。

            再有缺点就是想主动释放单例对象是无法控制的。

    懒汉模式和饿汉模式的对比

    饿汉

    优点：简单

    缺点：

    1. 如果单例对象构造函数工作比较多，会导致程序启动慢,迟迟进不了入口main函数
    2. 如果有多个单例对象，他们之间有初始化依赖关系，饿汉模式也会有问题。
          比如有A和B两个单例类，要求A单例先初始化，B必须在A之后初始化。那么饿汉无法保证这种场景下面用懒汉就可以，懒汉可以先调用 A::GetInstance() ，再调用 B::GetInstance() 。

    懒汉

    优点：解决上面饿汉的缺点。因为他是第一次调用 GetInstance 时创建初始化单例对象

    缺点：相对饿汉，复杂一点点。

             如上就是 特殊类的设计 的所有知识，如果大家喜欢看此文章并且有收获，可以支持下 兔7 ，给 兔7 三连加关注，你的关注是对我最大的鼓励，也是我的创作动力~！

            再次感谢大家观看，感谢大家支持！

  • 相关阅读:
    百分点大数据技术团队：解读ToB产品架构设计的挑战及应对方案
    【自然语言处理】【文本生成】Transformers中用于语言生成的不同解码方法
    JS-数组
    学习笔记2--高精度地图定义及价值
    项目架构之 -- 提交代码时的ESLint校验
    golang的垃圾回收算法之七标记过程
    【神经网络与深度学习】Transformer原理
    您的captcha验证码设置对了吗？
    离散时间系统模型
    SpringBoot读取.yml配置文件最常见的两种方式-源码及其在nacos的应用
  • 原文地址：https://blog.csdn.net/weixin_69725192/article/details/126240984