以下是几种实现单例模式并保证全局唯一性的方法：
1. 饿汉式单例模式
class Singleton {
private:// 私有构造函数，防止外部创建对象Singleton() {}// 静态成员变量，存储单例对象static Singleton instance;
public:// 公有静态成员函数，用于获取单例对象static Singleton& getInstance() {return instance;}
};// 静态成员变量的初始化，在程序启动时创建单例对象
Singleton Singleton::instance;解释：
- 构造函数私有化：将
Singleton类的构造函数声明为private，确保外部无法直接创建该类的对象。 - 静态成员变量：使用
static Singleton instance存储单例对象。 - 静态成员函数：通过
static Singleton& getInstance()提供获取单例对象的接口。 - 全局初始化：在程序启动时，
Singleton::instance就会被创建，因为它是静态成员，且在类外进行了定义和初始化。这保证了在程序运行的任何时刻，getInstance()都能返回同一个对象。
2. 懒汉式单例模式（线程不安全）
class Singleton {
private:// 私有构造函数，防止外部创建对象Singleton() {}// 静态成员变量，存储单例对象static Singleton* instance;
public:// 公有静态成员函数，用于获取单例对象static Singleton* getInstance() {if (instance == nullptr) {instance = new Singleton();}return instance;}
};// 静态成员变量的初始化，初始化为 nullptr
Singleton* Singleton::instance = nullptr;解释：
- 构造函数私有化：与饿汉式相同，将构造函数设为
private。 - 静态指针成员变量：使用
static Singleton* instance存储单例对象的指针，初始化为nullptr。 - 静态成员函数：
getInstance()函数在首次调用时检查instance是否为nullptr，若为nullptr则创建对象，后续调用都将返回同一个对象。 - 线程不安全：这种方式在多线程环境下存在问题，多个线程可能同时检查到
instance为nullptr，并同时创建对象，导致多个实例的出现。
3. 懒汉式单例模式（线程安全，使用互斥锁）
#include <mutex>class Singleton {
private:// 私有构造函数，防止外部创建对象Singleton() {}// 静态成员变量，存储单例对象static Singleton* instance;// 互斥锁，用于线程同步static std::mutex mtx;
public:// 公有静态成员函数，用于获取单例对象static Singleton* getInstance() {std::unique_lock<std::mutex> lock(mtx);if (instance == nullptr) {instance = new Singleton();}return instance;}
};// 静态成员变量的初始化，初始化为 nullptr
Singleton* Singleton::instance = nullptr;
// 静态成员变量的初始化，创建互斥锁
std::mutex Singleton::mtx;解释：
- 构造函数私有化：确保外部无法直接创建对象。
- 静态指针成员变量：存储单例对象的指针，初始化为
nullptr。 - 互斥锁：使用
std::mutex mtx进行线程同步。 - 静态成员函数：在
getInstance()中，使用std::unique_lock获取互斥锁，确保同一时刻只有一个线程可以创建单例对象。 - 性能问题：这种方式每次调用
getInstance()都需要加锁，即使instance已经创建，会影响性能。
4. 懒汉式单例模式（线程安全，双重检查锁定）
#include <mutex>class Singleton {
private:// 私有构造函数，防止外部创建对象Singleton() {}// 静态成员变量，存储单例对象static Singleton* instance;// 互斥锁，用于线程同步static std::mutex mtx;
public:// 公有静态成员函数，用于获取单例对象static Singleton* getInstance() {if (instance == nullptr) {std::unique_lock<std::mutex> lock(mtx);if (instance == nullptr) {instance = new Singleton();}}return instance;}
};// 静态成员变量的初始化，初始化为 nullptr
Singleton* Singleton::instance = nullptr;
// 静态成员变量的初始化，创建互斥锁
std::mutex Singleton::mtx;解释：
- 构造函数私有化：防止外部创建对象。
- 静态指针成员变量：存储单例对象指针，初始化为
nullptr。 - 互斥锁：用于线程同步。
- 静态成员函数：使用双重检查锁定，第一次检查
instance是否为nullptr是无锁的，若为nullptr则加锁再次检查并创建对象，避免了每次调用getInstance()都加锁的性能问题。 - 潜在问题：在某些编译器和处理器架构下，由于指令重排，可能导致
instance已经分配内存但未完成构造函数调用，导致其他线程访问到未完全初始化的对象。
5. 懒汉式单例模式（线程安全，C++11 及以上）
#include <memory>
#include <mutex>class Singleton {
private:// 私有构造函数，防止外部创建对象Singleton() {}
public:// 公有静态成员函数，用于获取单例对象static Singleton& getInstance() {static std::once_flag flag;std::call_once(flag, []() {instance.reset(new Singleton());});return *instance.get();}
private:// 静态成员变量，存储单例对象static std::unique_ptr<Singleton> instance;
};// 静态成员变量的初始化，使用智能指针存储单例对象
std::unique_ptr<Singleton> Singleton::instance;解释：
- 构造函数私有化：防止外部创建对象。
- 静态成员函数：使用
std::once_flag和std::call_once保证单例对象只被创建一次。 - 智能指针：使用
std::unique_ptr<Singleton> instance存储单例对象，避免了内存管理问题。 - C++11 特性：
std::call_once是 C++11 引入的，确保instance只会被调用一次，且是线程安全的，解决了双重检查锁定的指令重排问题。
6、总结
通过以上几种方式，可以实现单例模式并保证全局唯一性。在实际应用中，推荐使用 C++11 及以上的 std::call_once 和 std::unique_ptr 实现，它提供了简洁、安全和高效的单例模式实现方式。
上述几种实现方式都旨在保证单例模式的全局唯一性，但各有优缺点，你可以根据实际需求和开发环境选择合适的实现方式。**代码解释**：
- **饿汉式单例模式**：- 优点：实现简单，在程序启动时就创建单例对象，保证了线程安全和全局唯一性。- 缺点：可能会造成资源浪费，因为单例对象在程序开始时就创建，无论是否使用。- **懒汉式单例模式（线程不安全）**：- 优点：单例对象在首次使用时创建，避免了资源浪费。- 缺点：在多线程环境下无法保证单例对象的唯一性，会出现多个实例。- **懒汉式单例模式（线程安全，使用互斥锁）**：- 优点：使用互斥锁保证了多线程环境下的单例对象唯一性。- 缺点：性能开销大，每次调用 `getInstance()` 都要加锁，即使单例对象已经创建。- **懒汉式单例模式（双重检查锁定）**：- 优点：在多线程环境下相对高效，避免了每次调用都加锁。- 缺点：存在指令重排的潜在风险，可能导致获取到未完全初始化的对象。- **懒汉式单例模式（线程安全，C++11及以上）**：- 优点：结合了 `std::call_once` 和 `std::unique_ptr`，既保证了线程安全，又避免了指令重排问题，是现代 C++ 推荐的实现方式。- 缺点：需要 C++11 及以上标准支持。
