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. 代码结果：

 4. 注意：

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