> 作者：დ旧言~
> 座右铭：松树千年终是朽，槿花一日自为荣。
> 目标：理解特殊类，能自己模拟实现特殊类。
> 毒鸡汤：白日莫闲过，青春不再来。
> 专栏选自：C嘎嘎进阶
> 望小伙伴们点赞👍收藏✨加关注哟💕💕
🌟前言
在C++的学习的过程中，我们已经知道如何创建一个类，之后我们学习了类的三大特性封装，继承，多态，在C++11中我们有一些特殊的类，我们称这些类为--->特殊类，那特殊类真的有那么特殊么？？？
⭐主体
学习【C++11】特殊类设计咱们按照下面的图解：
🌙 设计一个类，不能被拷贝
拷贝只会发生在两个场景中：
- 拷贝构造函数
- 赋值运算符重载。
因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
💫 C++98方法：
解决方案：
将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。
举个栗子：
class CopyBan { public: CopyBan() {} private: CopyBan(const CopyBan& cb); // 拷贝构造函数声明 CopyBan& operator=(const CopyBan& cb); // 赋值运算符重载声明 };
说明原因：
- 设置成私有：如果只声明而没有设置成 private，用户自己如果在类外定义了，就可以不能禁止拷贝了。
- 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没什么意义，不写反而更简单，而且如果定义了就不能防止成员函数内部拷贝了。
总结：
如上图代码，在对这个特殊类进行拷贝和赋值的时候，因为这两个成员函数私有而无法调用。
拷贝构造以及赋值运算符重载等成员函数，在调用时都是编译器在域外调用，所以必须是公有的。
💫 C++11方法：
C++11 扩展了 delete 的用法，delete 除了释放 new 申请的资源以外，如果在默认成员函数后跟上 = delete，表示让编译器删除掉该默认成员函数，此时编译器也不会自动生成默认的拷贝构造和赋值运算符重载函数。
举个栗子：
class CopyBan { public: CopyBan() {} private: CopyBan(const CopyBan& cb) = delete; // 拷贝构造函数声明 CopyBan& operator=(const CopyBan& cb) = delete; // 赋值运算符重载声明 };
🌙 设计一个类，只能在堆上创建对象
正常创建类对象时，会在栈上创建，并且自动调用构造函数来初始化。下面设计一个类，只能在堆上创建对象。只能在堆上创建对象的含义就是：必须使用new来创建对象.
实现方式：
只能在创建在堆上时，就需要让该对象只能通过 new 来创建，并且调用构造函数来初始化。
- 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
- 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。
举个栗子：
class HeapOnly { public: static HeapOnly* CreateObject() { return new HeapOnly; } private: //构造函数 HeapOnly() {} HeapOnly(const HeapOnly& hp) = delete; // 禁止拷贝 };
总结分析：
定义一个静态成员函数，在该函数内部 new 一个 HeapOnly 对象。将构造函数和拷贝构造函数私有，并且禁止生成拷贝构造函数。
分析原因：
- 使用静态成员函数 new 一个 HeapOnly 对象。
- 那么非静态成员函数在调用时，必须使用点 (.) 操作符来调用，这一步是为了传 this 指针。这样的前提是先有一个 HeapOnly 对象，但是构造函数设置成了私有，就无法创建这样一个对象。
- 而静态成员函数的调用不用传 this 指针，也就不需要必须有 HeapOnly 对象，只需要类域 :: 静态成员函数即可。静态成员函数属于 HeapOnly 域内，所以在 new 一个对象的时候，可以调用私有的构造函数。
- 禁止调用拷贝构造函数并且私有化。
这样做的目的是为了禁止拷贝，防止使用堆区上的 HeapOnly 对象在栈区上拷贝，如下面代码：
而禁止了拷贝构造就杜绝了这一行为，从而保证了 HeapOnly 对象只能在堆上创建。
🌙 设计一个类，只能在栈上创建对象
步骤如下：
- 主要是需要做到不能在堆上创建类对象。
- new 一个对象的时候，会调用该类的 operator new(size_t size) 函数，在释放资源的时候又会调用该类的 operator delete(void* p) 函数。
💫 方法一：
解决方案：
防止在堆上创建类对象就是要禁止调用 operator new(size_t size) 和 operator delete(void* p) 这两个函数。
举个栗子：
class StackOnly { public: // 构造函数 StackOnly() {} void* operator new(size_t size) = delete; // 禁止调用new void operator delete(void* p) = delete; // 禁止调用delete };
说明：
使用 delete 来禁止这两个函数的调用，那么在 new 一个对象的时候，就会产生编译错误，从而无法在堆区上创建类对象。
此时在堆上创建对象时就会报错，尝试引用已删除的函数。
💫 方法二：
解决方案：
另一种方式就是和之前一样，通过一个静态成员函数在栈区上创建一个类对象，并且将默认构造函数私有化，然后设计静态方法创建对象返回即可。
举个栗子：
class StackOnly { public: static StackOnly CreateObject() { return StackOnly(); } private: StackOnly() {} };
此时 new 一个对象的时候，由于默认构造函数私有而无法调用，所以报错。
总结分析：
但以上两种设计方法都有一个漏洞，类对象可以在静态区（数据段）上创建：
static StackOnly so = StackOnly::CreateObject();
设计特殊类的核心：
- 只能通过静态成员函数来创建类，封掉其他所有创建方式
🌙 设计一个类，不能被继承
💫 C++98 方法：
解决方法：
C++98 中构造函数私有化，派生类中调不到基类的构造函数则无法继承。
举个栗子：
// 基类 class NonInherit { private: // 基类构造函数私有 NonInherit() {} }; // 派生类 class B : public NonInherit {};
💫 C++11 方法：
解决方法：
使用 final 关键字来修饰类，表示该类不能被继承。
举个栗子：
class A final {};
🌙 设计一个类，只能创建一个对象
💫 设计模式：
概念阐述：
设计模式 （Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的 总结。
为什么会产生设计模式这样的东西呢：
就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。
使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。
💫 单例模式：
概念阐述：
- 一个类只能创建一个对象。
- 该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。
比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。
分析：
- 全局只有一个实例对象，所以将单例对象放在静态区 / 堆区（保证只创建一次）。
- 为了防止其他位置创建该对象，将构造函数私有。
- 为了防止拷贝，使用 delete 修饰拷贝构造和赋值运算符重载函数。
1. 饿汉模式
概念阐述：
就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。
举个栗子：
// 饿汉模式 // 优点：简单 // 缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。 class Singleton { public: static Singleton* GetInstance() { return _ins; } private: //限制类外随意创建对象 Singleton(const Singleton& s) = delete; Singleton& operator=(const Singleton& s) = delete; Singleton() {} private: static Singleton* _ins; }; Singleton* Singleton::_ins = new Singleton;
分析原因：
静态成员变量只能在类域外进行定义初始化。所以在 main 函数之前就将单例对象定义初始化，此时该单例对象创建在静态区上，而且仅有一个，后面就无法再创建。
为什么称之为饿汉模式呢？
不管将来会不会使用到这个单例对象，但是在程序一启动还没有进入 main 函数之前就创建一个唯一的实例对象。就像一个饿汉一样，一上来就先吃（创建单例对象）。
总结：
如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好。
饿汉单例模式优点：
- 保证全局（整个进程）只有唯一实例对象。
- 饿汉模式：一开始就创建对象，特别简单。
饿汉单例模式缺点：
- 多个单例对象 A、B、C 假设要求他们之间有依赖关系：依次创建就无法达到，无法保证顺序可能会导致进程启动很慢
如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避
免资源竞争，提高响应速度更好。
1. 饿汉模式
代码实现：
//懒汉模式 class Singleton { public: static Singleton* GetInstance() { if (_ins == nullptr)//双检查加锁,只有第一次进来时需要加锁,其他情况不用加锁 { imtx.lock(); if (_ins == nullptr)//第一次调用才创建实例! { _ins = new Singleton; } imtx.unlock(); } return _ins; } void DelInstance() { imtx.lock(); if (_ins != nullptr) { cout << "over!!!" << endl; delete _ins; _ins = nullptr; } imtx.unlock(); } private: //限制类外随意创建对象 Singleton(const Singleton& s) = delete; Singleton& operator=(const Singleton& s) = delete; Singleton() {} private: static Singleton* _ins; static mutex imtx; }; Singleton* Singleton::_ins = nullptr; mutex Singleton::imtx;
为什么称之为懒汉模式呢？
懒汉模式又叫做延时加载模式。如果单例对象构造十分耗时或者占用很多资源，比如加载插件、初始化网络连接、读取文件等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢，所以这种情况使用懒汉模式（延迟加载）更好。
优缺点：
优点：
- 第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序（通过代码顺序）自由控制。
缺点：
- 复杂。
- 如果不加锁是会出现线程安全的问题。但是加锁是会十分影响性能的，所以引入了双检查。那么既要保证线程安全+又要保证效率的问题。
🌟结束语
今天内容就到这里啦，时间过得很快，大家沉下心来好好学习，会有一定的收获的，大家多多坚持，嘻嘻，成功路上注定孤独，因为坚持的人不多。那请大家举起自己的小手给博主一键三连，有你们的支持是我最大的动力💞💞💞，回见。
