[C++][特殊类设计][单例模式]详细讲解

目录

1.[不能被拷贝]

  • 拷贝只会发生在两个场景中:
    • 拷贝构造函数 以及赋值运算符重载
    • 因此想要让一个类禁止拷贝, 只需让该类不能调用拷贝构造函数以及赋值运算符重载即可
  • C++98
    • 拷贝构造函数与赋值运算符重载只声明不定义 ,并且将其访问权限设置为私有即可
    • 原因:
      • **设置成私有:**如果只声明没有设置成private,用户自己如果在类外定义了,就不能禁止拷贝了
      • **只声明不定义:**不定义是因为该函数根本不会调用,定义了其实也没有什么意义,不写 反而还简单,而且如果定义了就不会防止成员函数内部拷贝了
cpp 复制代码
class CopyBan
{
    // ...
private:
    CopyBan(const CopyBan &);
    CopyBan& operator=(const CopyBan&);
    //...
};
  • C++11
    • C++11扩展delete 的用法,delete除了释放new申请的资源外,如果在默认成员函数后跟上 =delete,表示让编译器删除掉该默认成员函数
cpp 复制代码
class CopyBan
{
    // ...
    CopyBan(const CopyBan&) = delete;
    CopyBan& operator=(const CopyBan&) = delete;
    //...
};

2.[只能在堆上创建对象]

  • 实现方式:
    1. 类的构造函数私有拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象
    2. 提供一个静态的成员函数在该静态成员函数中完成堆对象的创建
cpp 复制代码
class HeapOnly
{
public:
    // 提供一个公有的,获取对象的方式,对象则控制是new出来的
    static HeapOnly* CreateObject()
    {
        return new HeapOnly;
    }

    // 防拷贝
    HeapOnly(const HeapOnly& hp) = delete;
    HeapOnly& operator=(const HeapOnly& hp) = delete;
private:
    // 构造函数私有
    HeapOnly()
    {}
};

3.[只能在栈上创建对象]

  • **方法一:**同上将构造函数私有化,然后设计静态方法创建对象返回即可
cpp 复制代码
class StackOnly
{
public:
    static StackOnly CreateObj()
    {
        return StackOnly();
    }

    // 不能防拷贝,若delete拷贝构造,则无法传值返回
    // 不好处理,算是一个小缺陷

    // 禁掉operator new可以把下面用new调用拷贝构造申请对象给禁掉
    // StackOnly obj = StackOnly::CreateObj();
    // StackOnly* ptr3 = new StackOnly(obj);

    void* operator new(size_t size) = delete;
    void operator delete(void* p) = delete;
private:
    StackOnly()
    {}
};

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

  • C++98
cpp 复制代码
// C++98中构造函数私有化,派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:
    static NonInherit GetInstance()
    {
        return NonInherit();
    }
private:
    NonInherit()
    {}
};
  • C++11**:final关键字,final修饰类,表示该类不能被继承**
cpp 复制代码
class A final
{
    // ....
};

5.[只能创建一个对象(单例模式)]

0. 设计模式

  • 设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结
  • 使用设计模式的目的:
    • 为了代码可重用性、让代码更容易被他人理解、保证代码可靠性
    • 设计模式使代码编写真正工程化;设计模式是软件工程的基石脉络,如同大厦的结构一样

1.单例模式

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

2.饿汉模式

  • 饿汉模式 -- 一开始(main函数之前)就创建出对象
  • 就是说不管你将来用不用,程序启动时就创建一个唯一的实例对象
  • 优点:
    • 简单、没有线程安全问题
    • 如果这个单例对象在多线程高并发环境下频繁使用,性能要求较高,那么显然使用饿汉模式来避免资源竞争,提高响应速度更好
  • 缺点:
    • 一个程序中,多个单例,并且有先后创建初始化顺序要求时,饿汉无法控制
    • 饿汉单例类,初始化时任务多,会影响程序启动速度
cpp 复制代码
class Singleton
{
public:
    static Singleton* GetInstance()
    {
        return &_inst;
    }
private:
    // 构造函数私有
    Singleton(){};

    // C++11 -- 防拷贝
    Singleton(Singleton const&) = delete;
    Singleton& operator=(Singleton const&) = delete;

    static Singleton _inst; // 声明
};
Singleton Singleton::_inst; // 在程序入口之前就完成单例对象的初始化

3.懒汉模式

  • 如果单例对象构造十分耗时或者占用很多资源,比如加载插件, 初始化网络连接,读取文件等等,而有可能该对象程序运行时不会用到,那么也要在程序一开始就进行初始化, 就会导致程序启动时非常的缓慢
  • 所以这种情况使用**懒汉模式(延迟加载)**更好
  • 优点:
    • 控制顺序
    • 不影响启动速度
  • 缺点:
    • 相对复杂
    • 线程安全问题要处理好
cpp 复制代码
class Singleton
{
public:
    static Singleton* GetInstance()
    {
        // 注意这里一定要使用Double-Check的方式加锁,才能保证效率和线程安全
        if (nullptr == _pinst)
        {
            m_mtx.lock();
            if (nullptr == _pinst) // 第一次调用的时候才创建对象
            {
                _pinst = new Singleton();
            }
            m_mtx.unlock();
        }
        return _pinst;
    }

    // 实现一个内嵌垃圾回收类
    class CGarbo
    {
    public:
        ~CGarbo()
        {
            if (Singleton::_pinst)
                delete Singleton::_pinst;
        }
    };

    // 定义一个静态成员变量,程序结束时,系统会自动调用它的析构函数从而释放单例对象
    static CGarbo Garbo;

private:
    // 构造函数私有
    Singleton(){};

    // 防拷贝
    Singleton(Singleton const &);
    Singleton& operator=(Singleton const&);

    static Singleton* _pinst;      // 单例对象指针
    static mutex m_mtx;            // 互斥锁
};

Singleton* Singleton::_pinst = nullptr;
Singleton::CGarbo Garbo;
mutex Singleton::m_mtx;

4.单例对象释放问题

  • 一般情况下,单例对象不需要释放的
    • 因为一般整个程序运行期间都可能会用它
    • 单例对象在进程正常结束后,也会资源释放
  • 有些特殊场景需要释放,比如单例对象析构时,要进行一些持久化(往文件、数据库写)操作
相关推荐
可均可可6 分钟前
C++之OpenCV入门到提高004:Mat 对象的使用
c++·opencv·mat·imread·imwrite
白子寰28 分钟前
【C++打怪之路Lv14】- “多态“篇
开发语言·c++
小芒果_0133 分钟前
P11229 [CSP-J 2024] 小木棍
c++·算法·信息学奥赛
gkdpjj39 分钟前
C++优选算法十 哈希表
c++·算法·散列表
王俊山IT40 分钟前
C++学习笔记----10、模块、头文件及各种主题(一)---- 模块(5)
开发语言·c++·笔记·学习
-Even-43 分钟前
【第六章】分支语句和逻辑运算符
c++·c++ primer plus
我是谁??1 小时前
C/C++使用AddressSanitizer检测内存错误
c语言·c++
发霉的闲鱼2 小时前
MFC 重写了listControl类(类名为A),并把双击事件的处理函数定义在A中,主窗口如何接收表格是否被双击
c++·mfc
小c君tt2 小时前
MFC中Excel的导入以及使用步骤
c++·excel·mfc
xiaoxiao涛2 小时前
协程6 --- HOOK
c++·协程