C++中如何实现单例模式_单例模式实现方法详解

单例模式的常见变种实现包括饿汉式、懒汉式和 meyers' singleton。1. 饿汉式在程序启动时即创建实例，线程安全但可能造成资源浪费；2. 懒汉式延迟加载，在首次使用时创建实例，需处理线程安全问题，双重检查锁定是其典型实现；3. meyers' singleton 利用 c++++11 静态局部变量的线程安全初始化特性，实现简洁且线程安全。这些实现方式各有优劣，适用于不同场景。

单例模式确保一个类只有一个实例，并提供一个全局访问点。核心在于控制实例的创建，防止外部随意实例化。

解决方案：

实现单例模式的关键在于：私有化构造函数，提供静态的获取实例方法，以及保证线程安全。

立即学习“C++免费学习笔记（深入）”；

#include 
#include 

class Singleton {
private:
    // 1. 私有化构造函数，防止外部直接创建实例
    Singleton() {
        std::cout << "Singleton created" << std::endl;
    }

    // 拷贝构造函数和赋值运算符也需要私有化，防止拷贝创建实例
    Singleton(const Singleton& other) = delete;
    Singleton& operator=(const Singleton& other) = delete;

    // 静态成员变量，用于保存唯一的实例
    static Singleton* instance;

    // 互斥锁，用于线程安全
    static std::mutex mutex;

public:
    // 2. 提供静态的获取实例方法
    static Singleton* getInstance() {
        // Double-Check Locking
        if (instance == nullptr) {
            std::lock_guard lock(mutex); // RAII 风格的锁
            if (instance == nullptr) {
                instance = new Singleton();
            }
        }
        return instance;
    }

    // 其他方法
    void doSomething() {
        std::cout << "Singleton doing something" << std::endl;
    }
};

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

int main() {
    Singleton* instance1 = Singleton::getInstance();
    Singleton* instance2 = Singleton::getInstance();

    // 验证是否是同一个实例
    if (instance1 == instance2) {
        std::cout << "Both instances are the same" << std::endl;
    }

    instance1->doSomething();

    return 0;
}

这段代码使用了双重检查锁定（Double-Check Locking）来保证线程安全，减少锁的竞争。std::lock_guard 利用 RAII 机制，在离开作用域时自动释放锁，避免忘记解锁。

单例模式有哪些常见的变种实现？

除了上述的双重检查锁定，还有饿汉式、懒汉式、以及 Meyers' Singleton 等变种。

• 饿汉式： 在程序启动时就创建实例，线程安全，但可能造成资源浪费。

  class SingletonEager {
  private:
      SingletonEager() {}
      static SingletonEager instance; // 在类加载时就初始化
  
  public:
      static SingletonEager* getInstance() {
          return &instance;
      }
  };
  
  SingletonEager SingletonEager::instance;

• 懒汉式： 在第一次使用时才创建实例，延迟加载，但需要考虑线程安全问题。 双重检查锁定就是一种懒汉式的线程安全实现。

• Meyers' Singleton： 利用 C++11 的静态局部变量的线程安全初始化特性，实现简单且线程安全的单例。

  class SingletonMeyers {
  private:
      SingletonMeyers() {}
      SingletonMeyers(const SingletonMeyers&) = delete;
      SingletonMeyers& operator=(const SingletonMeyers&) = delete;
  
  public:
      static SingletonMeyers& getInstance() {
          static SingletonMeyers instance; // 静态局部变量，线程安全初始化
          return instance;
      }
  };

单例模式在多线程环境下如何保证线程安全？

线程安全是单例模式的关键问题，尤其是在多线程环境下。除了双重检查锁定，还可以使用互斥锁、原子操作等方式来保证线程安全。

施乐在线订单系统

一套简单的数据库结构的在线订单系统，采用数据库存储格式，方便的实现产品的在线订购，带有后台管理模块用户名为： admin 密码: ojdj22 修改密码方法如下， 更改 ckpwd.asp 中 第三行 if (user="用户名" and pwd="密码") 即可

下载

• 互斥锁： 使用 std::mutex 保护实例的创建过程，确保只有一个线程可以创建实例。双重检查锁定就是使用了互斥锁。

• 原子操作： 使用 std::atomic 来保证实例指针的原子性操作，避免多个线程同时创建实例。

  #include 
  
  class SingletonAtomic {
  private:
      SingletonAtomic() {}
      SingletonAtomic(const SingletonAtomic&) = delete;
      SingletonAtomic& operator=(const SingletonAtomic&) = delete;
  
      static std::atomic instance;
      static std::mutex mutex;
  
  public:
      static SingletonAtomic* getInstance() {
          SingletonAtomic* expected = nullptr;
          SingletonAtomic* desired = new SingletonAtomic();
          if (instance.compare_exchange_strong(expected, desired)) {
              return desired;
          } else {
              delete desired;
              return instance.load();
          }
      }
  };
  
  std::atomic SingletonAtomic::instance(nullptr);
  std::mutex SingletonAtomic::mutex;

单例模式有哪些应用场景和优缺点？

单例模式常用于以下场景：

• 资源管理器： 管理共享资源，如数据库连接池、线程池等。
• 配置管理器： 读取和管理应用程序的配置信息。
• 日志管理器： 统一管理应用程序的日志输出。
• 全局唯一ID生成器： 生成全局唯一的ID。

优点：

• 控制实例数量，节省资源。
• 提供全局访问点，方便访问。
• 可以延迟加载，提高程序启动速度。

缺点：

• 可能违反单一职责原则，增加类的复杂性。
• 不利于单元测试，因为单例实例的状态难以控制。
• 在多线程环境下需要考虑线程安全问题。

单例模式的生命周期如何管理，如何避免内存泄漏？

单例模式的生命周期管理需要特别注意，尤其是在程序退出时，需要释放单例实例占用的内存，避免内存泄漏。

• 手动释放： 在程序退出时，手动调用 delete 释放单例实例。但这需要保证在所有使用单例实例的地方都已释放完毕。

  int main() {
      Singleton* instance = Singleton::getInstance();
      instance->doSomething();
  
      // 程序退出时释放单例实例
      delete instance;
      Singleton::instance = nullptr;
  
      return 0;
  }

• 使用智能指针： 使用 std::unique_ptr 或 std::shared_ptr 管理单例实例，利用 RAII 机制自动释放内存。

  #include 
  
  class SingletonSmartPtr {
  private:
      SingletonSmartPtr() {}
      SingletonSmartPtr(const SingletonSmartPtr&) = delete;
      SingletonSmartPtr& operator=(const SingletonSmartPtr&) = delete;
  
      static std::unique_ptr instance;
      static std::mutex mutex;
  
  public:
      static SingletonSmartPtr* getInstance() {
          std::lock_guard lock(mutex);
          if (instance == nullptr) {
              instance = std::unique_ptr(new SingletonSmartPtr());
          }
          return instance.get();
      }
  };
  
  std::unique_ptr SingletonSmartPtr::instance = nullptr;
  std::mutex SingletonSmartPtr::mutex;

使用智能指针可以简化内存管理，避免手动释放内存可能造成的错误。选择哪种方式取决于具体的应用场景和需求。