单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实例。在 C++ 中，可以通过将构造函数设为私有，并提供一个静态方法来获取或创建类的实例来实现单例模式。
下面是一个简单的 C++ 单例模式的实现示例：
#include <iostream>
#include <mutex> // 用于线程安全（可选） class Singleton {
private: // 私有的静态指针，指向单例对象 static Singleton* instance; // 私有的构造函数，防止外部创建实例 Singleton() {} // 私有的拷贝构造函数和赋值运算符，防止拷贝 Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; // 静态互斥锁（可选，用于多线程环境） static std::mutex mtx; public: // 静态方法，用于获取单例对象 static Singleton* getInstance() { // 使用互斥锁保证线程安全（可选） std::lock_guard<std::mutex> lock(mtx); // 如果实例不存在，则创建它 if (instance == nullptr) { instance = new Singleton(); } return instance; } // 其他公共成员函数... void doSomething() { std::cout << "Singleton is doing something." << std::endl; } // 静态析构函数（可选），用于在程序结束时清理单例对象 // 注意：C++11 开始支持静态成员和局部对象的析构函数，但通常不推荐这样做 // 因为在程序结束时，所有资源都应该被自动清理 static void destroyInstance() { if (instance != nullptr) { delete instance; instance = nullptr; } } // 析构函数设为保护或私有的（可选），防止外部删除实例
protected: ~Singleton() { // 单例对象销毁时的清理工作（如果有的话） }
}; // 初始化静态成员（在类外部）
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mtx; // 使用示例
int main() { Singleton* s1 = Singleton::getInstance(); Singleton* s2 = Singleton::getInstance(); // s1 和 s2 指向同一个对象 if (s1 == s2) { std::cout << "s1 and s2 are the same instance." << std::endl; } s1->doSomething(); // 调用单例对象的成员函数 // 在程序结束时，可以调用 destroyInstance 来清理单例对象（通常不推荐） // Singleton::destroyInstance(); return 0;
}注意：
- 在多线程环境中，上述示例中的
getInstance方法不是线程安全的。为了确保线程安全，可以使用互斥锁（如std::mutex）来保护创建实例的代码块。 - 在 C++11 及更高版本中，可以使用局部静态变量的方式来实现线程安全的单例模式，因为局部静态变量的初始化是线程安全的。
- 析构函数通常不需要设为保护或私有的，因为单例对象应该在程序结束时自动被销毁。但在某些情况下，为了防止外部代码误删单例对象，可以将析构函数设为保护或私有的。如果这样做，需要提供一个静态方法来清理单例对象（如
destroyInstance），但这通常不推荐，因为它可能导致资源泄漏或其他问题。
在 C++11 及以后的版本中，我们可以使用更简洁和线程安全的方式来实现单例模式。以下是一个基于 C++11 的线程安全单例模式的实现示例：
#include <iostream>
#include <memory>
#include <mutex> class Singleton {
private: // 静态成员指针，指向单例对象 static std::unique_ptr<Singleton> instance; // 私有的构造函数 Singleton() {} // 禁止拷贝和移动 Singleton(const Singleton&) = delete; Singleton& operator=(const Singleton&) = delete; Singleton(Singleton&&) = delete; Singleton& operator=(Singleton&&) = delete; public: // 静态方法，用于获取单例对象 static Singleton& getInstance() { // 使用 std::call_once 来保证线程安全 static std::once_flag flag; std::call_once(flag, [] { instance.reset(new Singleton()); }); return *instance; } // 其他成员函数... void doSomething() { std::cout << "Singleton is doing something." << std::endl; } // 不需要显式销毁单例，unique_ptr 会在程序结束时自动处理
}; // 初始化静态成员（在类外部）
std::unique_ptr<Singleton> Singleton::instance; // 使用示例
int main() { Singleton& s1 = Singleton::getInstance(); Singleton& s2 = Singleton::getInstance(); // s1 和 s2 引用同一个对象 if (&s1 == &s2) { std::cout << "s1 and s2 are the same instance." << std::endl; } s1.doSomething(); // 调用单例对象的成员函数 return 0;
}在这个实现中，我们使用了 std::unique_ptr 来管理单例对象的生命周期，确保在程序结束时能够自动释放内存。同时，我们使用了 std::call_once 和 std::once_flag 来保证 getInstance 方法的线程安全性。由于 std::call_once 保证了初始化函数只会被执行一次，因此即使多个线程同时调用 getInstance 方法，也只会有一个线程创建单例对象。
此外，我们还使用了引用 Singleton& 而不是指针 Singleton* 来返回单例对象，这样可以简化代码并减少出错的可能性。由于 std::unique_ptr 已经管理了对象的生命周期，我们不需要担心内存泄漏或其他与内存管理相关的问题。
)
