单例模式（Singleton Pattern）是一种设计模式，确保一个类只有一个实例，并且提供全局访问点。实现单例模式的关键是防止类被多次实例化，且能够保证实例的唯一性。常见的实现手法包括懒汉式、饿汉式、线程安全的懒汉式等。

1. 饿汉式（Eager Initialization）

饿汉式单例在程序启动时就创建实例，并且保证只有一个实例。适用于单例实例比较简单、没有资源消耗问题的情况。

class Singleton {
public:
    // 提供静态的访问方式
    static Singleton& getInstance() {
        return instance;  // 直接返回静态实例
    }

private:
    Singleton() {}  // 构造函数私有化，防止外部创建实例
    ~Singleton() {}

    Singleton(const Singleton&) = delete;  // 禁止拷贝构造函数
    Singleton& operator=(const Singleton&) = delete;  // 禁止赋值

    static Singleton instance;  // 静态实例，程序启动时创建
};

// 静态实例必须定义在类外
Singleton Singleton::instance;

注意：
Singleton Singleton::instance;应在类的实现文件（.cpp 文件）中定义。如果静态成员变量的定义（如 Singleton Singleton::instance;）也放在头文件中，由于头文件可能被多个源文件包含，就会导致多重定义错误。

优点：

• 简单直接，保证了类的实例唯一。
• 实例在程序启动时就被创建，不会受到多线程的影响。

缺点：

• 无法延迟实例化。即使单例没有被使用，实例也会在程序启动时创建，可能会浪费资源。

在饿汉式单例中，实例在程序启动时就被创建，因此你无需显式地调用 getInstance() 来创建对象。它是静态的，并且一开始就存在。你只能通过 getInstance() 方法来访问该实例。

以下是如何在代码中调用饿汉式单例的示例：

完整代码示例

#include <iostream>
using namespace std;

class Singleton {
public:
    // 提供静态的访问方式
    static Singleton& getInstance() {
        return instance;  // 直接返回静态实例
    }

    void showMessage() {
        cout << "Singleton instance is working!" << endl;
    }

private:
    Singleton() { cout << "Singleton Constructor Called!" << endl; }  // 构造函数私有化
    ~Singleton() { cout << "Singleton Destructor Called!" << endl; }

    Singleton(const Singleton&) = delete;  // 禁止拷贝构造函数
    Singleton& operator=(const Singleton&) = delete;  // 禁止赋值

    static Singleton instance;  // 静态实例，程序启动时创建
};

// 静态实例必须定义在类外
Singleton Singleton::instance;

int main() {
    // 通过调用 getInstance 来获取单例实例
    Singleton& s1 = Singleton::getInstance();
    s1.showMessage();

    // 由于我们不能复制实例，以下代码会编译错误：
    // Singleton s2 = Singleton::getInstance();  // 编译错误，不能复制单例

    // 单例是全局唯一的，只能通过 getInstance() 获取
    return 0;
}

代码解析：

1. 静态实例定义：

   • static Singleton instance; 在类内部声明了一个静态的实例，该实例在程序启动时被创建。
   • 静态变量 instance 的生命周期从程序开始直到程序结束，所以它是全局唯一的。

2. getInstance() 方法：

   • static Singleton& getInstance() 提供了一个全局的访问点，用来获取唯一的实例。这个方法返回一个对静态成员 instance 的引用。

3. 在 main() 中的使用：

   • 在 main() 函数中，我们通过 Singleton::getInstance() 获取了单例实例，并调用了实例的方法 showMessage()。
   • 单例实例的构造函数在第一次调用 getInstance() 时自动执行，但我们并没有显式地创建 Singleton 对象。

输出：

Singleton Constructor Called!
Singleton instance is working!

注意事项：

• 全局唯一：Singleton::getInstance() 返回的是同一个对象，所以每次调用 getInstance() 都会得到相同的实例。
• 构造函数：构造函数只在第一次调用 getInstance() 时执行一次，因此 Singleton Constructor Called! 只会打印一次。
• 禁止复制：拷贝构造函数和赋值运算符被删除，避免了实例的复制。编译时如果尝试复制单例实例（如 Singleton s2 = Singleton::getInstance();），会导致编译错误。

总结：

通过 Singleton::getInstance() 方法获取单例实例，这是调用饿汉式单例的标准方式。由于饿汉式实例在程序启动时就被创建，所以你不需要显式地进行实例化操作。

2. 懒汉式（Lazy Initialization）

懒汉式是在需要实例时才创建实例，这样可以延迟实例化，提高资源的使用效率。基本实现没有线程安全，多个线程同时访问时可能会出现问题。

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

private:
    Singleton() {}  // 构造函数私有化
    ~Singleton() {}

    Singleton(const Singleton&) = delete;  // 禁止拷贝构造函数
    Singleton& operator=(const Singleton&) = delete;  // 禁止赋值

    static Singleton* instance;
};

// 静态实例初始化为空指针
Singleton* Singleton::instance = nullptr;

优点：

• 实例化延迟，只有在第一次使用时才创建实例，避免了不必要的资源消耗。

缺点：

• 不是线程安全的。在多线程环境下，可能会创建多个实例。

3. 线程安全的懒汉式

为了确保线程安全，可以使用互斥锁（mutex）来同步访问，确保只有一个线程能够创建实例。

#include <mutex>

class Singleton {
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mutex);  // 加锁确保线程安全
            if (instance == nullptr) {
                instance = new Singleton();
            }
        }
        return instance;
    }

private:
    Singleton() {}  // 构造函数私有化
    ~Singleton() {}

    Singleton(const Singleton&) = delete;  // 禁止拷贝构造函数
    Singleton& operator=(const Singleton&) = delete;  // 禁止赋值

    static Singleton* instance;
    static std::mutex mutex;  // 互斥锁
};

// 静态实例初始化为空指针
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

优点：

• 线程安全，保证在多线程环境下只有一个实例被创建。

缺点：

• 使用互斥锁增加了性能开销，尤其是频繁访问 getInstance() 时。

4. 双重检查锁（Double-Checked Locking）

双重检查锁定是懒汉式的优化版本，它减少了锁的使用频率。在第一次检查时不加锁，只有当实例为 nullptr 时才加锁，这样可以避免每次调用 getInstance() 时都进行加锁操作。

#include <mutex>

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

private:
    Singleton() {}  // 构造函数私有化
    ~Singleton() {}

    Singleton(const Singleton&) = delete;  // 禁止拷贝构造函数
    Singleton& operator=(const Singleton&) = delete;  // 禁止赋值

    static Singleton* instance;
    static std::mutex mutex;  // 互斥锁
};

// 静态实例初始化为空指针
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

优点：

• 提供了线程安全的懒汉式实现，且避免了每次都加锁的性能开销。

缺点：

• 代码相对复杂，需要小心实现。对 instance 的访问需要特别注意线程间的同步。

5. 静态局部变量（最推荐的实现方式）

使用静态局部变量来实现单例模式，这种方式是线程安全的，并且实现简单。C++11标准及以上可以确保静态局部变量的初始化是线程安全的。

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

private:
    Singleton() {}  // 构造函数私有化
    ~Singleton() {}

    Singleton(const Singleton&) = delete;  // 禁止拷贝构造函数
    Singleton& operator=(const Singleton&) = delete;  // 禁止赋值
};

优点：

• 简洁、线程安全。
• 在程序启动时不会立即创建实例，而是等到第一次使用时创建。
• 不需要显式加锁。

缺点：

• 只适用于需要在第一次使用时实例化的情况。

总结

• 饿汉式：简单，适合不需要延迟初始化的场景，程序启动时就创建实例。
• 懒汉式：适合需要延迟初始化的场景，但需要考虑线程安全。
• 线程安全懒汉式：通过加锁保证线程安全，但可能带来性能开销。
• 双重检查锁：线程安全，减少了加锁的频率，但实现复杂。
• 静态局部变量：线程安全，简洁，现代 C++ 中推荐的单例实现方式。

在现代 C++ 中，静态局部变量是实现单例模式的首选方法，既保证了线程安全，又没有性能开销，是最优选择。