单例模式（C++）

本文介绍: 单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点。这有助于控制资源的共享，以及限制对特定资源的访问权限。在单例模式中，通常通过私有构造函数和静态方法来实现。

单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点。这有助于控制资源的共享，以及限制对特定资源的访问权限。在单例模式中，通常通过私有构造函数和静态方法来实现。

懒汉式（Lazy Ini ti aliza t ion）：

懒汉式是指在第一次请求实例时才创建实例。这种方式避免了在程序启动时就创建对象，延迟了对象的实例化时间。

C++懒汉式单例 模式 示例：

#include &lt;iostream&gt;

class SingletonLazy {
private:
    static SingletonLazy *instance;
    
    // 私有构造函数，防止外部直接实例化
    SingletonLazy() {}
    
public:
    // 获取实例的静态方法
    static SingletonLazy *getInstance() {
        if (instance == nullptr) {
            instance = new SingletonLazy();
        }
        return instance;
    }
    
    // 其他成员方法
    void showMessage() {
        std::cout << "Hello from SingletonLazy!" << std::endl;
    }
};

// 在程序开始时，静态成员需要在类外初始化
SingletonLazy *SingletonLazy::instance = nullptr;

int main() {
    SingletonLazy *lazyInstance1 = SingletonLazy::getInstance();
    lazyInstance1->showMessage();

    SingletonLazy *lazyInstance2 = SingletonLazy::getInstance();
    
    // 判断是否是同一个实例
    if (lazyInstance1 == lazyInstance2) {
        std::cout << "Both instances are the same." << std::endl;
    } else {
        std::cout << "Instances are different." << std::endl;
    }

    return 0;
}

饿汉式（Eager Initi alization）：

饿汉式是指在类加载的时候就创建实例，因此无论是否需要都会创建一个实例。这种方式在多线程环境下需要小心，可能会导致资源浪费。

C++饿汉式单例 模式 示例：

#include <iostream>

class SingletonEager {
private:
    // 在类加载时就创建实例
    static SingletonEager *instance;

    // 私有构造函数，防止外部直接实例化
    SingletonEager() {}

public:
    // 获取实例的静态方法
    static SingletonEager *getInstance() {
        return instance;
    }

    // 其他成员方法
    void showMessage() {
        std::cout << "Hello from SingletonEager!" << std::endl;
    }
};

// 在程序开始时，静态成员需要在类外初始化
SingletonEager *SingletonEager::instance = new SingletonEager();

int main() {
    SingletonEager *eagerInstance1 = SingletonEager::getInstance();
    eagerInstance1->showMessage();

    SingletonEager *eagerInstance2 = SingletonEager::getInstance();
    
    // 判断是否是同一个实例
    if (eagerInstance1 == eagerInstance2) {
        std::cout << "Both instances are the same." << std::endl;
    } else {
        std::cout << "Instances are different." << std::endl;
    }

    return 0;
}

区别：

初始化时机：
- 懒汉式： 实例在第一次被请求时才创建。
- 饿汉式： 实例在类加载时就创建。
线程安全性：
- 懒汉式： 需要在多线程环境中使用额外的同步机制，以确保只有一个实例被创建。
- 饿汉式： 在多线程环境中，由于实例在类加载时就创建，因此不需要额外的同步机制。
资源浪费：
- 懒汉式： 避免了在程序启动时就创建实例，可能会在实际需要时再进行实例化，减少了资源浪费。
- 饿汉式： 在程序启动时就创建实例，可能会造成不必要的资源浪费，尤其在实例很大或者实例化代价较高时。