C++的单例模式

忘记之前有没有写过单例模式了。
再记录一下：
我使用的代码：

#ifndef SINGLETON_MACRO_HPP
#define SINGLETON_MACRO_HPP#define SINGLETON_DECL(class_name) \
public: \static class_name& instance() { \static class_name s_instance; \return s_instance; \} \
private: \class_name();\class_name(const class_name&) = delete; \class_name& operator=(const class_name&) = delete;#endif // SINGLETON_MACRO_HPP

双锁单例：

#include <iostream>
#include <mutex>class Singleton {
private:static Singleton* instance;static std::mutex mtx;// 私有化构造函数，确保不能在类外部进行实例化Singleton() {}public:// 删除复制构造函数和复制赋值操作符Singleton(const Singleton& other) = delete;Singleton& operator=(const Singleton& other) = delete;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;int main() {Singleton* s1 = Singleton::getInstance();Singleton* s2 = Singleton::getInstance();if (s1 == s2) {std::cout << "Both instances are identical." << std::endl;} else {std::cout << "Instances are different." << std::endl;}return 0;
}

单例模式的不同实现方式各有优缺点

双检锁（Double Checked Locking）：

优点：
线程安全。
在实例已经被创建之后，直接返回实例，避免了每次获取实例时都需要获取锁的开销。
缺点：
代码相对复杂。
在某些老的编译器或硬件架构上，双检锁可能无法正常工作，可能需要内存屏障或其他同步机制。

静态局部变量（Meyers’ Singleton）：

class Singleton {
public:static Singleton& getInstance() {static Singleton instance;return instance;}
private:Singleton() {}
};

优点：
线程安全（在 C++11 及以后的版本中）。
代码简单、清晰。
延迟初始化：只有在首次调用 getInstance 时，实例才会被创建。
缺点：
对于老的 C++ 标准（C++11 之前），这种方法可能不是线程安全的。

饿汉式：

class Singleton {
private:static Singleton instance;Singleton() {}
public:static Singleton& getInstance() {return instance;}
};

优点：
线程安全，因为实例在程序开始时就已经被初始化。
代码简单。
缺点：
实例在程序开始时就被创建，即使它从未被使用，可能会导致不必要的资源占用或初始化开销。

懒汉式（简单）：

class Singleton {
private:static Singleton* instance;Singleton() {}
public:static Singleton* getInstance() {if (!instance) {instance = new Singleton();}return instance;}
};