写点什么

C++ 特殊类的设计

作者:可口也可樂
  • 2022-11-23
    湖南
  • 本文字数:3287 字

    阅读完需:约 11 分钟

C++特殊类的设计

@TOC

零、前言

本章我们主要讲解学习特殊类的设计方式

一、不能被拷贝

想要让一个类禁止拷贝,只需让该类不能调用拷贝构造函数以及赋值运算符重载即可


  • 方式 1:


C++98 下,私有化拷贝构造函数与赋值运算符重载并且只声明不定义


  • 示例代码:


class NoCopy{public:    NoCopy()        :_a(0)    {}private:    NoCopy(const NoCopy& oh);//只声明不用实现(C98)    NoCopy& operator=(const NoCopy& oh) ;    int _a;};
复制代码


  • 解释:


  1. 设置成私有:如果只声明没有设置成 private,用户自己如果在类外定义了,就可以不能禁止拷贝了

  2. 只声明不定义:不定义是因为该函数根本不会调用,定义了其实也没有什么意义


  • 方式二:


C++11 下,在拷贝构造函数与赋值运算符重载函数后跟上=delete


  • 示例代码:


class NoCopy{public:    NoCopy()        :_a(0)    {}private:    NoCopy(const NoCopy& oh)=delete;//C++11    NoCopy& operator=(const NoCopy& oh)=delete;    int _a;};
复制代码


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


  • 示图:


二、只能在堆上创建对象

  • 方式 1:


构造函数私有化,栈上创建的对象销毁调用不了析构函数而报错;给定特有的销毁函数,对堆上变量进行销毁


  • 示例代码:


class OnlyHeap{public:    void Destory()    {        delete this;//类函数里调用delete        cout << "delete" << endl;    }private:    ~OnlyHeap()//析构函数私有化,栈上创建的对象销毁不能调用会报错    {        cout << "~OnlyHeap" << endl;    }
int _a;};
复制代码


  • 解释:


  1. 构造函数私有化:对于栈上创建的对象销毁调用不了析构函数会报错,也就是间接的不让创建栈对象

  2. 给定特有的销毁函数:在类函数里可以访问私有成员,进行 delete 时能够使用私有的析构函数并进行释放对象


  • 方式 2:


私有化构造函数,拷贝构造。防止别人调用拷贝在栈上生成对象;提供静态的成员函数,在该静态成员函数中完成堆对象的创建


  • 示例代码:


class OnlyHeap{public:    static OnlyHeap* ObjCreat()//提供对象创建的静态成员方法    {        cout << "new OnlyHeap" << endl;        return new OnlyHeap;    }private:    OnlyHeap()//禁止直接调用构造        :_a(0)    {        cout << "OnlyHeap" << endl;    }    OnlyHeap(const OnlyHeap& oh);//防止拷贝    OnlyHeap& operator=(const OnlyHeap& oh);
int _a;};
复制代码


  • 解释:


  1. 私有化构造函数/拷贝构造:防止别人调用拷贝在栈上生成对象

  2. 提供静态创建对象函数:在该静态成员函数中完成堆对象的创建,类里的函数能够调用私有化的构造函数


注:一定是静态的成员函数,静态成员函数不需要依赖对象进行调用,普通的成员函数则不行


  • 示图:


三、只能在栈上创建对象

  • 方式 1:


显示声明并私有化 operator new/operator delete 函数


  • 示例代码:


class OnlyStack{public:    OnlyStack()        :_a(0)    {        cout << "Onlystack" << endl;    }private:    //显示成私有化避免调用    void* operator new(size_t size);    void operator delete(void* p);
int _a;};
复制代码


  • 解释:


显示私有化:显示是为了让 new 的时候找到对象专属的 operator new 函数,私有化则是为了不让 operator new 函数不被成功使用,避免调用


注:唯一的缺点是不能避免在静态区创建对象


  • 示图:



  • 方式 2:


私有化构造函数,提供特定创建对象的静态成员函数


  • 示例代码:


class OnlyStack{public:    static OnlyStack ObjCreat()    {        return OnlyStack();//类里进行调用构造    }private:    OnlyStack()//构造私有化,避免new调用        :_a(0)    {        cout << "OnlyStack" << endl;    }    int _a;};
复制代码


  • 解释:


私有化构造函数:new 一个对象=调用类的构造函数+operator new(),这里避免 new 调用创建对象

四、不能被继承的类

  • 方式 1:


在 C++98 下,私有化构造函数,提供特定的创建静态成员函数


  • 示例:


class NonInherit{public:    static NonInherit GetInstance()    {        return NonInherit();    }private:    // 构造函数私有    NonInherit()    {}};class Derive : NonInherit{};
复制代码


  • 解释:


C++98 这种方式不够直接,这里是可以继承的,但是 Derive 不能创建对象,因为 Derive 的构造函数必须要调用父类 NonInherit 构造,但是 NonInherit 的构造函数私有了,私有在子类不可见,那么这里继承不会报错,继承的子类创建对象会报错


  • 方式 2:


final 修饰类,表示该类不能被继承


  • 示例代码:


class NoInherit final{};
class Derive : NoInherit{};
复制代码


  • 示图:


五、只能创建一个对象

  • 设计模式的概念:


设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结


  • 使用设计模式的目的:


为了代码可重用性、让代码更容易被他人理解、保证代码可靠性;设计模式使代码编写真正工程化


  • 单例模式:


一个类只能创建一个对象,即单例模式,该模式可以保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享


  • 比如:


在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息,这种方式简化了在复杂环境下的配置管理


  • 单例模式有两种实现模式:


饿汉模式和懒汉模式

1、饿汉模式

当程序启动时就创建一个唯一的实例对象


  • 示例代码:


class Singleton{public:    static Singleton& GetInstance()//获取实例地址    {        return _s;    }    vector<int> _v;//可以选择私有也可以选择公有private:    Singleton();//构造私有化,禁止随意构造    //delete拷贝构造和赋值函数,防拷贝赋值    Singleton(const Singleton& s) = delete;    Singleton& operator=(const Singleton& s) = delete;
static Singleton _s;//在类里的变量都是声明,在cpp文件中进行定义};
复制代码


  • 解释:


类里面的成员变量只是声明,而静态成员对象需要在类外进行定义,并且不能在.h 文件中定义,如果多个.cpp 文件包含该头文件,那么则会报重复定义的错误


  • 效果:



  • 优势:


实现简单


  • 劣势:


  1. 如果单例对象构造十分耗时或者占用很多资源,比如加载插件啊, 初始化网络连接啊,读取文件啊等等,而有可能该对象程序运行时不会用到,那么也要在程序一开始就进行初始化,就会导致程序启动时非常的缓慢

  2. 对于多个单例类的如果具有依赖关系的话,则无法进行控制定义顺序(静态变量)

2、懒汉模式

懒汉模式则是需要的时候在第一次调用的时候进行创建


  • 示例代码:


class Singleton{public:    //提供获取对象以及释放对象的静态方法    static Singleton& GetInstance()    {        //提高效率,避免多次锁住及解锁        if (_s == nullptr)        {            //保证线程安全            _m.lock();//锁住            if (_s == nullptr)            {                _s = new Singleton;            }            _m.unlock();//解锁        }        return *_s;    }    static void DelInstance()    {        //提高效率,避免多次锁住及解锁        if (_s != nullptr)        {            //保证线程安全            _m.lock();//锁住            if (_s != nullptr)            {                delete _s;                _s = nullptr;            }            _m.unlock();//解锁        }    }    vector<int> _v;private:    Singleton() {};//要有函数体,否则只是声明,当new的时候找不到对应的实体    Singleton(const Singleton& s) = delete;    Singleton& operator=(const Singleton& s) = delete;    static Singleton* _s;//储存实例对象地址    static mutex _m;//互斥锁};
复制代码


  • 解释:


对于懒汉模式需要注意的是要保证线程安全,当多个进行调用 GetInstance()/DelInstance()时,可能多次进行 new 和 delete,可能造成数据的丢失


  • 效果:



  • 优势:


无启动负载;可以自由控制多个单例类的定义顺序


  • 劣势:


实现复杂


发布于: 刚刚阅读数: 4
用户头像

还未添加个人签名 2022-04-28 加入

还未添加个人简介

评论

发布
暂无评论
C++特殊类的设计_c++_可口也可樂_InfoQ写作社区