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

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

下次还敢

发布： 2025-07-07 12:23:57

原创

886人浏览过

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

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

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

解决方案：

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

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

#include <iostream>
#include <mutex>

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<std::mutex> 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;
    }
};

登录后复制

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

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

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

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

#include <atomic>

class SingletonAtomic {
private:
    SingletonAtomic() {}
    SingletonAtomic(const SingletonAtomic&) = delete;
    SingletonAtomic& operator=(const SingletonAtomic&) = delete;

    static std::atomic<SingletonAtomic*> 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*> 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 <memory>

class SingletonSmartPtr {
private:
    SingletonSmartPtr() {}
    SingletonSmartPtr(const SingletonSmartPtr&) = delete;
    SingletonSmartPtr& operator=(const SingletonSmartPtr&) = delete;

    static std::unique_ptr<SingletonSmartPtr> instance;
    static std::mutex mutex;

public:
    static SingletonSmartPtr* getInstance() {
        std::lock_guard<std::mutex> lock(mutex);
        if (instance == nullptr) {
            instance = std::unique_ptr<SingletonSmartPtr>(new SingletonSmartPtr());
        }
        return instance.get();
    }
};

std::unique_ptr<SingletonSmartPtr> SingletonSmartPtr::instance = nullptr;
std::mutex SingletonSmartPtr::mutex;

登录后复制

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

以上就是C++中如何实现单例模式_单例模式实现方法详解的详细内容，更多请关注php中文网其它相关文章！