单例模式

单例模式：

1.作用

确保一个类只有一个实例存在。单例模式的实例是全局唯一的。

2.原理

确保一个类只有一个实例，那么它的构造函数就一定不能是公开public的，即不能被外界实例化。那它的构造方法只能是private的。

它只有一个实例，实例属于当前类，即这个实例是当前类的静态成员变量。

再提供一个静态的方法，向外界提供当前类的实例。

3.实现方法

class Singleton{
    
private:
	static Singleton *instance; //单例为静态成员变量,类内声明,类外初始化
	Singleton(){
    };  //构造函数设为私有
};
Singleton *singleton::intstance = nullptrl; //类外初始化静态变量

(1)饿汉式

饿汉式：在类加载时就进行实例化

#include <iostream>
using namespace std;

class Singleton{
    
public:
    // 提供全局访问点
    static Singleton& getInstance()
    {
    
        // 静态局部变量在程序启动时初始化
        static Singleton instance;
        return instance;
    }

    // 删除拷贝构造函数和赋值操作符，防止复制
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 示例方法
    void display() const{
    
        cout << "Singleton::display() called on instance: " << this << endl;
    }
private:
    // 私有构造函数
    Singleton(){
    
        cout << "Singleton()" << endl;
    }
    // 私有析构函数
    ~Singleton(){
    
        cout << "~Singleton()" << endl;
    }
};

int main()
{
    
    // 通过getInstance获取单例对象的引用，并调用示例方法
    Singleton& s1 = Singleton::getInstance();
    s1.display();

    // 再次获取单例对象的引用，验证它们是同一个实例
    Singleton& s2 = Singleton::getInstance();
    s2.display();

    // 输出将展示s1和s2有相同的地址，说明它们是同一个实例
    return 0;
}

(2)懒汉式 / 懒加载

懒汉式：类加载时不进行实例化，在第一次使用时才进行实例化。

单线程实现：

static Singleton *getInstance(){
    
    if(nullptr == pInstance){
    
        pInstance = new Singleton();
    }
    return pInstance;
}

多线程实现：(保证线程安全)

#include <iostream>
#include <mutex>

using std::cout;
using std::endl;

class Singleton {
    
public:
    static Singleton* getInstance() {
    
        std::call_once(initInstanceFlag, &Singleton::initSingleton);
        return _pInstance;
    }

    static void destroy() {
    
        delete _pInstance;
        _pInstance = nullptr;
    }

    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    Singleton() {
    
        cout << "Singleton()" << endl;
    }
    ~Singleton() {
    
        cout << "~Singleton()" << endl;
    }

    static void initSingleton() {
    
        _pInstance = new Singleton();
    }

    static Singleton* _pInstance;
    static std::once_flag initInstanceFlag;
};

Singleton* Singleton::_pInstance = nullptr;
std::once_flag Singleton::initInstanceFlag;

int main() {
    
    Singleton* ps1 = Singleton::getInstance();
    Singleton* ps2 = Singleton::getInstance();
    cout << "ps1 = " << ps1 << endl;
    cout << "ps2 = " << ps2 << endl;

    Singleton::destroy();

    return 0;
}