• C++精通之路:设计模式(特殊类设计)


    很多小伙伴为了刷题发愁
    今天为大家推荐一款刷题神奇哦:刷题面试神器牛客
    各大互联网大厂面试真题。从基础到入阶乃至原理刨析类面试题 应有尽有,赶快来装备自己吧!助你面试稳操胜券,solo全场面试官

    C++精通之路:设计模式(特殊类设计)

    • 本节内容:

    介绍常见特殊类的设计方式

    1.请设计一个类,只能在堆上创建对象

    • 实现方式:
    1. 将类的构造函数私有,拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
    2. 提供一个静态的成员函数,在该静态成员函数中完成堆对象的创建
    3. 从而达到了在栈上无法开辟空间,只能通过CreateObject()函数在堆上创建空间
    class HeapOnly
    {
    public:
    	static HeapOnly* CreateObj()
    	{
    		return new HeapOnly;//因为构造函数已经是私有的了,所以只能通过这个函数来创建对象
    	}
         //在堆区的拷贝函数
    	//static HeapOnly* CopyObj(const HeapOnly& h)
    	//{
    	//	return new HeapOnly(h);
    	//}
    private:
    	HeapOnly()
    	{}
    	// 拷贝构造私有,并且只声明不实现(实现也是可以,但是没人用)
    	// C++98 -- 防拷贝
    	/*HeapOnly(const HeapOnly&)
    	{}*/
    	//public:
    	//	// C++11
    	HeapOnly(const HeapOnly&) = delete;
    };
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    在堆上不能创建:

    在堆上通过CreateObj()函数即可创建对象

    image-20220830175531681

    2. 请设计一个类,只能在栈上创建对象

    • 方法一:

    同理,将构造函数私有化,然后设计静态方法创建对象返回即可。

    class StackOnly
    {
    public:
    static StackOnly CreateObject()
    {
    return StackOnly();
    }
    private:
    StackOnly() {}
    };
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 方法二:屏蔽new
    1. 原理是用私有的new来覆盖掉编译器提供的全局new,从而达到屏蔽new的效果

    2. 因为new在底层调用void* operator new(size_t size)函数,只需将该函数屏蔽掉即可。
      注意:也要防止定位new

    class StackOnly
    {
    public:
    StackOnly() {}
    private:
    void* operator new(size_t size);
    void operator delete(void* p);
    };
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    3. 请设计一个类,不能被拷贝

    拷贝只会放生在两个场景中:

    1. 拷贝构造函数
    2. 赋值运算符重载

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

    • C++98
    class CopyBan
    {
    // ...
    private:
    CopyBan(const CopyBan&);
    CopyBan& operator=(const CopyBan&);
    //...
    };
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    拷贝构造函数与赋值运算符重载只声明不定义,并且将其访问权限设置为私有即可

    • 原理:
    1. 设置成私有:如果只声明没有设置成private,用户自己如果在类外定义了,就可以不能禁止拷贝了
    2. 只声明不定义:不定义是因为该函数根本不会调用,定义了其实也没有什么意义,不写反而还简单,而且如果定义了就不会防止成员函数内部拷贝了。
    • C++11 :

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

    class CopyBan
    {
    // ...
    CopyBan(const CopyBan&)=delete;
    CopyBan& operator=(const CopyBan&)=delete;
    //...
    };
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    4. 请设计一个类,不能被继承

    • C++98方式
    // C++98中构造函数私有化,派生类中调不到基类的构造函数。则无法继承
    class NonInherit
    {
    public:
    static NonInherit GetInstance()
    {
    return NonInherit();
    }
    private:
    NonInherit()
    {}
    };
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    原理:子类调不到父类的构造函数,所以不能实例化,所以无法继承

    • C++11方法

    final关键字,**final****修饰类,表示该类不能被继承。

    class A final
    {
    // ....
    };
    
    • 1
    • 2
    • 3
    • 4

    5. 请设计一个类,只能创建一个对象(单例模式)

    设计模式

    • 介绍:

    设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢?就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期,七国之间经常打仗,就发现打仗也是有套路的,后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。

    • 使用设计模式的目的:
    1. 为了代码可重用性
    2. 让代码更容易被他人理解
    3. 保证代码可靠性。
    4. 设计模式使代码编写真正工程化
    5. 设计模式是软件工程的基石脉络,如同大厦的结构一样。
    • 实现:

    一个类只能创建一个对象,即单例模式,该模式可以保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享。比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息,这种方式简化了在复杂环境下的配置管理。

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

    饿汉模式

    就是说不管你将来用不用,程序启动时就创建一个唯一的实例对象。

    class Singleton
    {
    public:
    static Singleton* GetInstance()
    {
    return &m_instance;
    }
    private:
    // 构造函数私有
    Singleton(){};
    // C++98 防拷贝
    Singleton(Singleton const&);
    Singleton& operator=(Singleton const&);
    // or
    // C++11
    Singleton(Singleton const&) = delete;
    Singleton& operator=(Singleton const&) = delete;
    static Singleton m_instance;
    };
    Singleton Singleton::m_instance; // 在程序入口之前就完成单例对象的初始化
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 优点:
      1. 简单
      2. 如果这个单例对象在多线程高并发环境下频繁使用,性能要求较高,那么显然使用饿汉模式来避免资源竞争,提高响应速度更好。
    • 缺点:
      1. 可能会导致进程启动慢(因为要在程序运行初始化好对象,对象过大时可能会导致初始化运行时间过长,从而让用户感受到进程启动慢)。
      2. 且如果有多个单例类对象实例启动顺序不确定。所以假如在继承条件下,无法保证父类在子类之前初始化。

    懒汉模式

    如果单例对象构造十分耗时或者占用很多资源,比如加载插件啊, 初始化网络连接啊,读取文件啊等等,而有可能该对象程序运行时不会用到,那么也要在程序一开始就进行初始化,就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式(延迟加载)更好。

    #include 
    #include 
    #include 
    using namespace std;
    class Singleton
    {
    public:
    static Singleton* GetInstance() {
    // 注意这里一定要使用Double-Check的方式加锁,才能保证效率和线程安全
    if (nullptr == m_pInstance) //双重判断,使效率提高
    {
         m_mtx.lock();
      if (nullptr == m_pInstance) 
      {
      m_pInstance = new Singleton();
      }
        m_mtx.unlock();
    }
    return m_pInstance;
    }
    // 实现一个内嵌垃圾回收类
    class CGarbo {
    public:
    ~CGarbo(){
    if (Singleton::m_pInstance)
    delete Singleton::m_pInstance;
    }
    };
    // 定义一个静态成员变量,程序结束时,系统会自动调用它的析构函数从而释放单例对象
    static CGarbo Garbo;
    private:
    // 构造函数私有
    Singleton(){};
    // 防拷贝
    Singleton(Singleton const&);
    Singleton& operator=(Singleton const&);
    static Singleton* m_pInstance; // 单例对象指针
    static mutex m_mtx; //互斥锁
    };
    Singleton* Singleton::m_pInstance = nullptr;
    Singleton::CGarbo Garbo;
    mutex Singleton::m_mtx;
    void func(int n)
    {
    cout<< Singleton::GetInstance() << endl;
    }
    
    int main()
    {
    thread t1(func, 10);
    thread t2(func, 10);
    t1.join();
    t2.join();
    cout << Singleton::GetInstance() << endl;
    cout << Singleton::GetInstance() << endl;
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 优点:
    1. 进程启动无负载。
    2. 多个单例实例启动顺序自由控制。
    3. 不会出现饿汉模式下:如果有多个单例类对象实例启动顺序不确定的情况
    • 缺点:
    1. 复杂 ,因为在多线程下,单例模式下的对象相当于临界资源.
      1. 饿汉模式下,在程序启动时就将对象初始化了,要调用对象时,只需返回指针(只进行了读操作,没有进行写操作)。所以不需要管理此行为
      2. 而在懒汉模式下,在程序启动时,对象未初始化。需要在static Singleton* GetInstance() 函数内初始化,这里就有对临界资源的写操作了,所以要用到互斥锁等工具来保护临界资源,较为复杂

    总结:

    以上这几种设计都是通过staic的特性来实现的

    1. 前面四种条件是通过将目标函数私有化,使其在外部不可调用。且用staic成员函数来在特定的条件下实行构造。(用到了staic成员函数可在类未初始化时就可调用的特性)

    2. 单例模式则是通过staic成员变量的原子性来实现的。单例模式利用了一个staic 成员指针,指向一个类。再通过将目标函数(构造函数等)私有化,使其在外部不可调用。且用staic成员函数来实现对类的构造。

      1. 在创造的时机上又有两种模式:

              1. 懒汉模式
              2. 饿汉模式
        
        • 1
        • 2

    ps

    想和博主一样刷优质面试和算法题嘛,快来刷题面试神器牛客吧,期待与你在牛客相见

  • 相关阅读:
    list的用法
    44、基于深度学习的癌症检测(matlab)
    DDR4硬件原理图设计详解
    【解决方案】在dbeaver中下载驱动提示网络错误
    C++设计模式-单件(Singleton)
    标准流布局
    利用浏览器将Markdown导出为HTML、PDF
    GET请求
    【黄啊码】mysql启动报错:The server quit without updating PID file[网上的都是坑货]
    转换流,序列化和反序列化,transient关键字笔记
  • 原文地址:https://blog.csdn.net/yin_ming_hui/article/details/126614238