C++常用设计模式:单例设计模式(饿汉式、懒汉式)

 一、单例模式的设计套路:

思考:如何绕过常规的构造函数,提供一种机制来保证一个类只有一个实例。

1. 铺垫:静态成员函数特性的总结 

使用static关键字修饰类成员函数时,就是把这个成员函数升级成了全局函数。只不过这个全局函数隐藏在这个类之中。

(1) 静态成员函数是没有this指针的。

(2) 静态成员函数是不可以调用类中的非静态成员,只能调用或访问类中的静态成员。

(3) 静态成员函数不依赖于成员对象,可以使用 类名+类域访问符的形式直接调用。

总结:静态成员函数与静态成员对象一样,是服务于整个类的,而不依赖于某个对象。

2. 思考题的解决过程:

(1) 要实现单例模式,先把构造函数私有化。

私有化带来的问题是:外部不可以定义对象,即不可以从外部调到类的构造函数。

解决:在类内定义一个公开的接口,返回本类对象的指针。


(2) 在public 权限下定义一个函数,返回出本类对象的指针。

问题:若函数是一个普通函数,需要依赖于类对象的调用才可以,这与只产生一个单例相矛盾。

解决:把这个函数升级为静态函数,无需依赖于对象的调用,可以直接调用。


(3) 把这个函数升为静态函数。

问题:静态函数是没有this指针,无法调用类中属性(无法访问普通属性)。

解决:把类中的属性升级为静态属性。静态成员函数只能调用静态成员属性。


(4) 把类中的本类的指针,升级为静态属性

至此,一个单例模式的程序完成。

 二、单例设计模式:

单例模式分为:饿汉式与懒汉式

三、饿汉式单例设计模式

1. 饿汉式:

(1) 构造函数私有化

(2) 在public权限下定义一个公有接口,返回本类对象的指针

(3) 公有接口提升为静态函数。

(4) 将类中属性定义为静态属性

(5) 因为是静态成员函数,所以不能在静态成员函数中书写开辟空间的逻辑,应该把开辟空间的逻辑写在全局作用域中。

2. 代码实现: 

#include 
using namespace std;
class Singleton
{
private: //对类内开放,对类外不开放
    static Singleton* singleton; //定义指针
    Singleton()
    {
        cout << "Singleton的构造"<< endl;
    }
public:
    //定义一个公有接口,返回本类对象的指针
    static Singleton* getInstance()
    {
        return singleton;
    }
    void showInfo()
    {
        cout << this << endl;
    }
    //把编译器自动提供的拷贝构造与 = 号运算符重载移除
    Singleton(const Singleton& other) = delete;
    void operator = (const Singleton& other) = delete;
};

Singleton* Singleton::singleton = new Singleton;
int main()
{
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();
    Singleton* s3 = Singleton::getInstance();

    cout << s1 << ","<< s2 <<"," << s3 <

3. 代码结果:

 

4. 饿汉式缺点: 

静态成员空间只能初始化一次,这块空间是不能释放的,这就占用了空间资源。每使用一次饿汉式单例,程序一加载singleton这个指针就开辟空间,造成内存浪费。

 四、懒汉式单例设计模式

1. 模式出现的问题与解决方式

》问题:当多进程存在的环境下,构造函数是需要耗费时间的,当一个进程开辟空间构造一个实例时,可能有另一个进程进来,也构造了一个实例,这样就不够安全。


》解决1:加智能锁。不使用智能锁采用普通锁,lock()和unlock()这种加锁与解锁的方式,若空间没开辟成功直接返回,这时锁没解开就生成死锁。而智能锁不管有没有成功开辟空间,出了作用域的同时调用lock()的析构函数把这个锁释放了,不会造成死锁。

》解决2:使用原子锁。

2. 代码实现:

#include 
#include 
using namespace std;
//定义全局锁
mutex mtx;
class Singleton
{
private:
    static Singleton* singleton;
    Singleton()
    {
        cout << "Singleton的构造" << endl;
    }
    ~Singleton()
    {
        cout <<"Singleton的析构" << endl;
    }
public:
    static Singleton* getInstance()
    {
        lock_guard lock(mtx);
        //mtx.lock();  普通锁
        if(singleton == nullptr)
        {
            singleton = new Singleton;
        }
        //mtx.unlock();
        return singleton;
    }
    void showInfo()
    {
        cout << this << endl;
    }
    //专门设计一个释放堆区空间的逻辑
    static void destroy()
    {
        //不要把这个逻辑放在析构函数中,将会出现无限递归
        if(singleton != nullptr)
        {
            delete singleton;
        }
    }
};
Singleton* Singleton::singleton = nullptr;
int main()
{
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();
    Singleton* s3 = Singleton::getInstance();
    s1->showInfo();
    s2->showInfo();
    s3->showInfo();
    Singleton::destroy();
    return 0;
}

3. 代码结果:

C++常用设计模式:单例设计模式(饿汉式、懒汉式)_第1张图片

 4. 注意:

销毁不能在析构函数中写,本身是单例销毁会陷入无限的递归、无限的死循环,所以要专门定义一个静态函数来销毁这个堆的空间。

你可能感兴趣的:(C++,c++,设计模式)