单例模式——C++实现

目录

1. 单例模式介绍

2. 饿汉式单例模式

3. 懒汉式单例模式

4. 单例模式的析构

---

1. 单例模式介绍

单例模式应该是大家耳熟能详的设计模式了，单例模式顾名思义就是使一个类只能存在一个具体实例的一种设计模式。

单例模式可以分为饿汉式单例模式和懒汉式设计模式。

饿汉式单例模式意思是在程序一开始就创建出对象。

懒汉式单例模式意思是在首次调用时才创建对象。懒汉式单例模式会涉及到现成安全的问题，具体的解决办法详见后续的处理。

2. 饿汉式单例模式

在类的静态实例定义时就直接new一个对象出来，对象创建是在main函数之前完成的，保证了线程安全。

#include 

using namespace std;

class Singleton
{
private:
    static Singleton* instance;
    Singleton() {}
    Singleton(const Singleton&)=delete;
    Singleton& operator=(const Singleton&)=delete;

public:
    static Singleton* getInstance()
    {
        if (instance == nullptr)
        {
            instance = new Singleton();
        }
        return instance;
    }
};

Singleton* Singleton::instance = new Singleton();

int main()
{
    Singleton* s1 = Singleton::getInstance();

    return 0;    
}

3. 懒汉式单例模式

懒汉式单例模式在类的静态实例定义时初始化为nullptr，首次调用时才会实例化对象。这种实现会导致线程安全问题，在多线程环境下可能会出现多个线程对instance进行实例化。

解决办法有两种，在main函数中，创建其他线程之前先调用一次Singleton::getInstance()，创建出来实例。另一种办法就是双重锁定的办法保证线程安全。

class Singleton
{
private:
    static Singleton* instance;
    Singleton() {}
    Singleton(const Singleton&)=delete;
    Singleton& operator=(const Singleton&)=delete;

public:
    static Singleton* getInstance()
    {
        if (instance == nullptr)
        {
            instance = new Singleton();
        }
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;

下面是利用双重锁定的方式实现线程安全的代码示例：

class Singleton
{
private:
    static Singleton* instance;
    static mutex mtx;
    Singleton() {}
    Singleton(const Singleton&)=delete;
    Singleton& operator=(const Singleton&)=delete;
public:
    static Singleton* getInstance()
    {
        if (instance == nullptr)
        {
            lock_guard lock(mtx);
            if (instance == nullptr)
            {
                instance = new Singleton();
            }
        }
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;

4. 单例模式的析构

一般情况下没办法确定单例对象什么时候析构，可以利用一种特殊的技巧来实现对单例模式的析构。下面展示利用嵌套类的方法实现对单例对象的析构。

class Singleton
{
private:
    static Singleton* instance;
    static mutex mtx;
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    class SingletonDeleter
    {
    public:
        ~SingletonDeleter()
        {
            if (Singleton::instance)
            {
                delete Singleton::instance;
                Singleton::instance = nullptr;
            }
        }
    };
    static SingletonDeleter deleter;
public:
    static Singleton* getInstance()
    {
        if (instance == nullptr)
        {
            lock_guard lock(mtx);
            if (instance == nullptr)
            {
                instance = new Singleton();
            }
        }
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;
Singleton::SingletonDeleter Singleton::deleter;

使用Singleton的嵌套类SingletonDeleter，作为Singleton的静态对象。当程序结束时，会自动执行对象的析构函数，此时就可以对单例类对象进行析构。