在面向对象编程中，单例模式是一种常见的设计模式，用于确保一个类只有一个实例，并提供一个全局访问点。C++中实现单例模式有多种方式，每种方式都有其特点和适用场景。本文将详细介绍懒汉模式、饿汉模式和Meyers模式的实现及其优缺点。

一、单例模式的基本要求

单例模式的核心要求是：

1. 唯一实例：确保一个类只有一个实例。

2. 全局访问点：提供一个全局访问点来获取这个唯一的实例。

为了实现这些要求，我们需要：

• 将类的构造函数设为私有，防止外部通过new创建实例。

• 提供一个静态方法来获取实例，并在内部控制实例的创建和销毁。

二、懒汉模式（延迟初始化）

懒汉模式的核心思想是延迟初始化，即在第一次调用时才创建实例。这种方式的优点是节省资源，因为实例只在需要时才会被创建。然而，懒汉模式需要解决线程安全问题，否则在多线程环境下可能会创建多个实例。

1、线程不安全

class Singleton
{
private:
    Singleton() {} // 私有构造函数，防止外部直接创建实例
    Singleton(const Singleton&) = delete; // 禁止拷贝构造
    Singleton& operator=(const Singleton&) = delete; // 删除赋值运算符

    static Singleton* instance; // 静态指针，用于存储单例实例

public:
    static Singleton* Get()
    {
        if (instance == nullptr)
        {
            instance = new Singleton(); // 如果实例不存在，则创建一个
        }
        return instance; // 返回单例实例
    }
};
Singleton* Singleton::instance = nullptr;//需要在类外初始化

2、通过加互斥锁来实现线程安全

#include <mutex>

class Singleton {
private:
    Singleton() {} // 私有构造函数
    Singleton(const Singleton&)=delete;
    Singleton& operator=(const Singleton&)=delete;
    static Singleton* instance; // 静态指针，存储唯一实例
    static std::mutex mtx; // 用于线程同步的互斥锁

public:
    static Singleton* getInstance() {
        if (instance == nullptr) { // 双重检查锁定
            std::lock_guard<std::mutex> lock(mtx); // 加锁
            if (instance == nullptr) { // 再次检查
                instance = new Singleton();
            }
        }
        return instance;
    }
   
};

// 初始化静态成员
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mtx;

优点

• 节省资源：实例只在需要时创建。

• 延迟初始化：符合按需加载的原则。

缺点

• 线程安全问题：需要额外的同步机制（如互斥锁）来确保线程安全。

• 代码复杂度较高：需要实现双重检查锁定机制。

三、饿汉模式（程序启动时初始化）

饿汉模式的核心思想是程序启动时即创建实例。这种方式的优点是线程安全，因为实例在程序启动时就已经创建好了，不存在并发问题。然而，它的缺点是可能会提前占用资源。

class Singleton {
private:
    Singleton() {} // 私有构造函数
    Singleton(const Singleton&) = delete; // 禁止拷贝构造
    Singleton& operator=(const Singleton&) = delete; // 禁止赋值操作
    static Singleton instance; 
public:
    static Singleton& getInstance() {
       
        return instance;
    }
};
Singleton  Singleton::instance; //类外初始化

优点

• 线程安全：实例在程序启动时创建，不存在并发问题。

• 简单易实现：代码简洁，无需额外的同步机制。

缺点

• 资源占用：实例在程序启动时就创建，可能会提前占用资源。

• 缺乏灵活性：实例的创建时机无法控制

四、Meyers模式（C++11线程安全）

Meyers模式是基于C++11标准的单例实现方式，利用了C++11中局部静态变量的线程安全特性。这种方式不仅实现了线程安全，而且代码简洁，是目前推荐的单例实现方式

class Singleton {
private:
    Singleton() {} // 私有构造函数
    Singleton(const Singleton&) = delete; // 禁止拷贝构造
    Singleton& operator=(const Singleton&) = delete; // 禁止赋值操作

public:
    static Singleton& getInstance() {
        static Singleton instance; // 局部静态变量
        return instance;
    }
};

优点

• 线程安全：C++11标准保证了局部静态变量的线程安全。

• 代码简洁：无需额外的同步机制，代码简洁易读。

• 延迟初始化：实例在第一次调用时创建，节省资源。

缺点

• C++11依赖：需要C++11及以上版本的编译器支持。

五、总结

单例模式在C++中有多种实现方式，每种方式都有其适用场景：

• 懒汉模式：适合资源占用较大的场景，但需要处理线程安全问题。

• 饿汉模式：适合资源占用较小且需要快速初始化的场景，但可能会提前占用资源。

• Meyers模式：是目前最推荐的方式，线程安全且代码简洁，适合大多数场景。

在实际开发中，可以根据具体需求选择合适的单例实现方式。