【C++高阶(八)】单例模式&特殊类的设计

微软技术分享微软全球最有价值专家

全栈领域优质创作者

博客专家认证

2024-01-20 09:26:44

单例模式

1. 前言+ 2. 设计一个不能被拷贝/继承的类+ 3. 只能在堆上创建对象的类+ 4. 只能在栈上创建对象的类+ 5. 只能实例化一个对象的类的介绍+ 6. 饿汉模式的具体实现+ 7. 懒汉模式的具体实现+ 8. 总结以及拓展

1. 前言

在实际场景中,总会遇见一些特殊情况, 比如设计一个类,只能在堆上开辟空间, 亦或者是设计一个类只能实例化一个对象在实际需求的场景下,来学习这节实用课

本章重点:

本篇文章着重讲解如何设计一些特殊的类,包括不能被拷贝,只能在栈/堆上创建对象以及此类只能实例化一个对象, 这也就是题目中的单例模式,单例模式又包含饿汉和懒汉模式,文章都是干货请同学们耐心学习!

2. 设计一个不能被拷贝/继承的类

设计一个不能被拷贝的类

C++11中引入的关键字delete 就能很好的解决这个问题,并且不仅仅要禁用拷贝,还有赋值!

class CopyBan
{
    CopyBan(const CopyBan&)=delete;
    CopyBan& operator=(const CopyBan&)=delete;
};

在C+98中,也有方法能够解决, 那就是显示将拷贝构造函数和赋值运算符重载函数私有化!

class CopyBan
{
private:
    CopyBan(const CopyBan&);
    CopyBan& operator=(const CopyBan&);
};

设计一个不能被继承的类

使用关键字final就能解决问题

class A  final
{
    // ....
};

在C++98中,将构造函数私有化也能达到目的,因为子类的构造会调用基类的构造,如果私有了基类的构造就会报错!

class NonInherit
{
private:
    NonInherit()
    {}
};

3. 只能在堆上创建对象的类

只能在堆上创建对象的含义就是必须使用new来创建对象.

本篇文章是实用性的,就直接讲方法了:

将析构函数私有化

将析构函数私有化后,由于对象析构时并不能调用到析构函数,所以不管是在堆上还是栈上创建对象都会报错!但是我们可以特殊处理,在共有域定义一个函数,此函数显示调用析构!

//思路一,封析构函数
class HeapOnly
{
public:
    void destory()
    {
        delete this;
    }
private:
    ~HeapOnly()
    {
        cout<<"调用析构成功!"<<endl;
    }
};

能否达到目的大家可以自行测试!

将构造函数私有化

将构造函数设置为私有后,不管是在堆上还是栈上都不能创建对象,但是我们可以在共有域写一个函数显示去调用构造函数,注意,这里的共有域函数必须设置为static类型,因为必须有了对象后才能调用函数,但是要调用了此函数才能创建对象,就会出现先有鸡还是先有蛋的问题,所以设置为static后,可以用类域调用!

//思路二,封构造函数
class HeapOnly
{
public:
    static HeapOnly* CreateObject(int x = 0)
    {
        return new HeapOnly(x);
    }
private:
    HeapOnly(int x = 0):_x(x)
    {}
    int _x;
};

以上两种方案真的就ok了吗?

事实上并不够ok,因为即使封掉了析构或者是构造,人们也能用拷贝构造或赋值来在栈上开辟空间,比如在方法二中,我们可以这样打破规则:

HeapOnly* ho1 = HeapOnly::CreateObject(10);
HeapOnly ho(*ho1);

所以在上面两种方案的基础上要禁用拷贝构造和赋值重载两个函数!

4. 只能在栈上创建对象的类

有了前面的思想,解决这个类型的问题就显示很小儿科了!

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

class StackOnly
{
public:
    static StackOnly CreateObj()
    {
        return StackOnly();
    }

// 禁掉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()  
        :_a(0)
    {}
    private:
    int _a;
};

5. 只能实例化一个对象的类的介绍

一个类只能实例化一个对象这就是大名鼎鼎的"单例模式"

谈单例模式前,先谈设计模式:

单例模式就是设计模式中的一种:

单例模式在实际场景下使用非常广泛如果你恰好在读我的并发内存池项目亦或者是你学过线程池(thread pool), 这里都能看见单例模式的影子,并且, 单例模式有两种实现模式:

饿汉模式:就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象+ 懒汉模式:第一次使用时才创建一个唯一的实例对象

6. 饿汉模式的具体实现

注意,这里实现的是样例(demo)代码,在不同的工程场景下需要大家做灵活的变换

// 饿汉模式
// 优点：简单
// 缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。
class Singleton
{
public:
    static Singleton* GetInstance()
    {
        return _ins;
    }
private:
    //限制类外随意创建对象
    Singleton(const Singleton& s) = delete;
    Singleton& operator=(const Singleton& s) = delete;
    Singleton()
    {}
private:
    static Singleton* _ins;
};
Singleton* Singleton::_ins = new Singleton;

单例模式的饿汉模式中,程序一启动就会把_ins,也就是唯一的实例对象给初始化, 并且由于构造函数被私有了,只能调用共有的GetInstance()函数获取_ins对象,又由于这个对象是static类型的,所以不管你调用多少次GetInstance()都获取的是同一个对象,也就是_ins

7. 懒汉模式的具体实现

//懒汉模式
class Singleton
{
public:
    static Singleton* GetInstance()
    {
        if (_ins == nullptr)//双检查加锁,只有第一次进来时需要加锁,其他情况不用加锁
        {
            imtx.lock();
            if (_ins == nullptr)//第一次调用才创建实例!
            {
                _ins = new Singleton;
            }
            imtx.unlock();
        }
        
        return _ins;
    }
    void DelInstance()
    {
        imtx.lock();
        if (_ins != nullptr)
        {
            cout << "over!!!" << endl;
            delete _ins;
            _ins = nullptr;
        }
        imtx.unlock();
    }
private:
    //限制类外随意创建对象
    Singleton(const Singleton& s) = delete;
    Singleton& operator=(const Singleton& s) = delete;
    Singleton()
    {}
private:
    static Singleton* _ins;
    static mutex imtx;
};
Singleton* Singleton::_ins = nullptr;
mutex Singleton::imtx;