文章目录
一、不能被拷贝的类
二、只能在堆上创建类对象
三、只能在栈上创建类对象
四、不能被继承的类
五、单例模式
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) 优点:
- 延迟实例化,只有第一次调用获取实例的方法时才会创建对象,避免了资源浪费。
- 可以控制对象的初始化顺序。
- 不影响程序的启动速度。
缺点:
- 不是线程安全的,如果多个线程并发地调用获取实例的方法,可能会创建多个实例。
- 在多线程环境下,需要额外的同步措施来保证线程安全,增加了复杂性开销。