青岛app网站开发,wordpress调用函数大全,管理部门网站建设说明书,微商城系统开发商文章目录 一、不能被拷贝的类 二、只能在堆上创建类对象 三、只能在栈上创建类对象 四、不能被继承的类 五、单例模式 5、1 什么是单例模式 5、2 什么是设计模式 5、3 单例模式的实现 5、3、1 饿汉模式 5、3、1 懒汉模式 #x1f64b;♂️ 作者#xff1a;Ggggggtm #x… 文章目录 一、不能被拷贝的类 二、只能在堆上创建类对象 三、只能在栈上创建类对象 四、不能被继承的类 五、单例模式 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;在C98中将拷贝构造函数与赋值运算符重载只声明不定义并且将其访问权限设置为私有也是可以的。 二、只能在堆上创建类对象 我们在栈和静态区创建对象时都需要调用构造函数来初始化。同时为了防止拷贝和赋值在栈空间上所以将默认构造、拷贝构造、赋值重载都禁用了。 那我们可以在类内部单独提供一个动态申请对象的静态成员函数。具体代码如下 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;
} 四、不能被继承的类 一个类不能被继承有两种方法 C98方式构造函数私有化派生类中调不到基类的构造函数。则无法继承。 class NonInherit
{
public:static NonInherit GetInstance(){return NonInherit();}
private:NonInherit(){}
}; C11方法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 优点 延迟实例化只有第一次调用获取实例的方法时才会创建对象避免了资源浪费。可以控制对象的初始化顺序。不影响程序的启动速度。 缺点 不是线程安全的如果多个线程并发地调用获取实例的方法可能会创建多个实例。在多线程环境下需要额外的同步措施来保证线程安全增加了复杂性开销。
