文章目录
一、不能被拷贝的类
二、只能在堆上创建类对象
三、只能在栈上创建类对象
四、不能被继承的类
五、单例模式
5、1 什么是单例模式
5、2 什么是设计模式
5、3 单例模式的实现
5、3、1 饿汉模式
5、3、1 懒汉模式
🙋♂️ 作者：@Ggggggtm 🙋♂️
👀 专栏：C++ 👀
💥 标题：特殊类的设计💥
❣️ 寄语：与其忙着诉苦，不如低头赶路，奋路前行，终将遇到一番好风景 ❣️
一、不能被拷贝的类
一个类拷贝都是由拷贝构造来完成的。拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。代码如下：
class NonCopyableClass { public: NonCopyableClass() {} private: // 禁用拷贝构造函数 NonCopyableClass(const NonCopyableClass&) = delete; // 禁用拷贝赋值运算符 NonCopyableClass& operator=(const NonCopyableClass&) = delete; }; int main() { NonCopyableClass obj1; // 编译错误，不能拷贝对象 // NonCopyableClass obj2(obj1); //NonCopyableClass obj3 = obj1; return 0;在C++98中，将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有也是可以的。
二、只能在堆上创建类对象
我们在栈和静态区创建对象时，都需要调用构造函数来初始化。同时，为了防止拷贝和赋值在栈空间上，所以将默认构造、拷贝构造、赋值重载都禁用了。
那我们可以在类内部单独提供一个动态申请对象的静态成员函数。具体代码如下：
class HeapOnly { public: // 提供一个公有的，获取对象的方式，对象控制是new出来的 static HeapOnly* CreateObj() { return new HeapOnly; } // 防拷贝 HeapOnly(const HeapOnly& hp) = delete; HeapOnly& operator=(const HeapOnly& hp) = delete; void Destroy() { delete this; } private: // 构造函数私有 HeapOnly() :_a(0) {} private: int _a; }; int main() { HeapOnly* hp = HeapOnly::CreateObj(); //HeapOnly copy(*hp); hp->Destroy(); return 0; }
三、只能在栈上创建类对象
为了防止在堆上或者静态区申请对象，构造函数应该私有。可以在类内部提供一个返回栈对象的方法。代码如下：
class StackOnly { public: static StackOnly CreateObj() { StackOnly st; return st; } private: // 构造函数私有 StackOnly() :_a(0) {} private: int _a; };但是，此时还能拷贝构造和赋值呢！！！那么能够禁用掉拷贝构造吗？答案是不能的。原因是我们通过传值返回的栈对象，此时必须需要拷贝。不能够传引用返回，因为是局部变量。出了函数就会被销毁。我们最多的就是禁用掉new的使用，具体代码如下：
class StackOnly { public: static StackOnly CreateObj() { StackOnly st; return st; } // 不能防拷贝 //StackOnly(const StackOnly& st) = delete; StackOnly& operator=(const StackOnly& st) = delete; void* operator new(size_t n) = delete; private: // 构造函数私有 StackOnly() :_a(0) {} private: int _a; }; int main() { StackOnly st1 = StackOnly::CreateObj(); // 拷贝构造 static StackOnly copy2(st1); //StackOnly* copy3 = new StackOnly(st1); return 0; }
四、不能被继承的类
一个类不能被继承有两种方法：
- C++98方式：构造函数私有化，派生类中调不到基类的构造函数。则无法继承。
class NonInherit { public: static NonInherit GetInstance() { return NonInherit(); } private: NonInherit() {} };- C++11方法：final关键字，final修饰类，表示该类不能被继承。
class A final { // .... };
五、单例模式
5、1 什么是单例模式
单例模式是一种设计模式，用于确保在整个应用程序中只存在一个特定类的实例对象，该实例对象被所有程序模块共享。其主要目的是限制类的实例化操作，以确保在任何情况下都只能获得同一个实例。
比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。
5、2 什么是设计模式
设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。
5、3 单例模式的实现
单例模式实现的方法有两种：饿汉模式、懒汉模式。我们先来看一下饿汉模式的实现。
5、3、1 饿汉模式
所谓饿汉模式，就是在main函数之前，就会创建出对象。并不会考虑到你是否要用这个对象。那怎么实现呢？
首先，为了保证只能实例出一份对象，就必须把构造函数私有化。其次，需要在自己的类内部定义一个静态的类对象或者类指针。然后在类内部定义一些静态成员函数来初始化、获取对象/指针等操作。具体代码如下：
//class MemoryPool //{ //public: // //private: // // 构造函数私有化 // MemoryPool() // {} // // char* _ptr = nullptr; // // ... // // static MemoryPool _inst; // 声明 //}; // 定义 //MemoryPool MemoryPool::_inst; class MemoryPool { public: static MemoryPool* GetInstance() { return _pinst; } void* Alloc(size_t n) { void* ptr = nullptr; // .... return ptr; } void Dealloc(void* ptr) { // ... } MemoryPool(MemoryPool& my) = delete; MemoryPool& operator= (MemoryPool& my) = delete; private: // 构造函数私有化 MemoryPool() {} char* _ptr = nullptr; // ... static MemoryPool* _pinst; // 声明 }; // 定义 MemoryPool* MemoryPool::_pinst = new MemoryPool; int main() { //MemoryPool pool1; //MemoryPool pool2; void* ptr1 = MemoryPool::GetInstance()->Alloc(10); MemoryPool::GetInstance()->Dealloc(ptr1); }我们来分析一下：当类内定义的是静态成员时，需要在类外进行初始化。那么在类外能够调用私有的构造函数进行初始化吗？答案是可以的！因为该成员是属于类内部的私有成员，只不过是在类外进行的初始化。
那么能在类内定义非静态类对象吗？答案是不可以的，这本身就是语法错误。其次静态成员变量并不属于某个对象，而是属于整个类。
总结饿汉模式（Eager Initialization） 的优点：
- 实现简单，线程安全。在类加载时就创建了实例，没有线程安全问题。
- 可以保证在任何时候获取到同一个实例。
缺点：
- 类加载时即创建实例，尤其是在实例初始化比较耗时的情况下，会影响到程序的启动速度。
- 如果该实例一直没有被使用，则会造成内存的浪费。
- 当有多个单例对象时，饿汉模式无法很好的控制其初始化先后顺序。当然，在一个文件內部还好，在多个文件中就无法确定静态成员的初始化顺序。
5、3、1 懒汉模式
如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好。
懒汉模式在第一次使用时才会创建单例对象，延迟实例化以节省资源。代码如下：class MemoryPool { public: static MemoryPool* GetInstance() { if (_pinst == nullptr) { _pinst = new MemoryPool; } return _pinst; } void* Alloc(size_t n) { void* ptr = nullptr; // .... return ptr; } void Dealloc(void* ptr) { // ... } // 实现一个内嵌垃圾回收类 class CGarbo { public: ~CGarbo() { if (_pinst) delete _pinst; } }; MemoryPool(MemoryPool& my) = delete; MemoryPool& operator= (MemoryPool& my) = delete; private: // 构造函数私有化 MemoryPool() { // .... } char* _ptr = nullptr; // ... static MemoryPool* _pinst; // 声明 }; // 定义 MemoryPool* MemoryPool::_pinst = nullptr; // 回收对象，main函数结束后，他会调用析构函数，就会释放单例对象 static MemoryPool::CGarbo gc;总结懒汉模式（Lazy Initialization） 优点：
- 延迟实例化，只有第一次调用获取实例的方法时才会创建对象，避免了资源浪费。
- 可以控制对象的初始化顺序。
- 不影响程序的启动速度。
缺点：
- 不是线程安全的，如果多个线程并发地调用获取实例的方法，可能会创建多个实例。
- 在多线程环境下，需要额外的同步措施来保证线程安全，增加了复杂性开销。
