C++如何实现单例模式保证全局唯一对象-C++-PHP中文网

C++如何实现单例模式保证全局唯一对象

P粉602998670

发布： 2025-09-12 09:54:02

原创

648人浏览过

单例模式通过私有构造函数、静态实例和全局访问点确保类唯一实例，常用静态初始化或双重检查锁实现线程安全，适用于日志、配置管理等场景，应避免滥用以降低耦合。

c++如何实现单例模式保证全局唯一对象

单例模式的核心在于确保一个类只有一个实例，并提供一个全局访问点。C++实现单例的关键在于控制对象的创建和访问。

解决方案

私有化构造函数和拷贝构造函数： 防止外部直接创建和复制对象。
静态成员变量： 用于存储唯一的实例。
静态成员函数： 提供全局访问点，负责创建和返回实例。
线程安全： 在高并发环境下，需要考虑线程安全问题。

下面是一个简单的C++单例模式实现：

#include <iostream>
#include <mutex>

class Singleton {
private:
    Singleton() {
        std::cout << "Singleton created" << std::endl;
    }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static Singleton* instance;
    static std::mutex mutex;

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

    void doSomething() {
        std::cout << "Singleton is doing something" << std::endl;
    }

    ~Singleton() {
        std::cout << "Singleton destroyed" << std::endl;
    }

    //防止内存泄漏
    class Garbo {
    public:
        ~Garbo(){
            if (Singleton::instance != nullptr) {
                delete Singleton::instance;
                Singleton::instance = nullptr;
            }
        }
    };

    static Garbo garbo;
};

Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;
Singleton::Garbo Singleton::garbo;


int main() {
    Singleton* instance1 = Singleton::getInstance();
    instance1->doSomething();

    Singleton* instance2 = Singleton::getInstance();
    instance2->doSomething();

    if (instance1 == instance2) {
        std::cout << "Both instances are the same" << std::endl;
    }

    //不需要手动释放，程序结束时会自动释放
    return 0;
}

登录后复制

这段代码首先私有化了构造函数和拷贝构造函数，阻止了外部直接实例化和复制

Singleton

登录后复制

对象。

getInstance

登录后复制

方法使用了双重检查锁（double-checked locking）模式，在多线程环境下确保只有一个实例被创建。

Garbo

登录后复制

类的静态成员变量在程序结束时会自动调用析构函数，从而释放单例对象的内存，避免内存泄漏。

如何保证单例模式的线程安全？

在高并发环境下，多个线程可能同时调用

getInstance

登录后复制

方法，导致创建多个实例。为了保证线程安全，可以使用互斥锁（mutex）来同步线程访问。

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

双重检查锁（Double-Checked Locking）是一种常用的线程安全单例模式实现方式，但需要注意内存模型问题。在C++11之后，由于内存模型的改进，双重检查锁可以正确工作。

除了互斥锁，还可以使用静态初始化来保证线程安全。静态变量的初始化在C++标准中是线程安全的，因此可以利用这一特性来简化单例模式的实现：

Robovision AI

一个强大的视觉AI管理平台

查看详情

class Singleton {
private:
    Singleton() {
        std::cout << "Singleton created" << std::endl;
    }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static Singleton& getInstance() {
        static Singleton instance; // 静态初始化，线程安全
        return instance;
    }

    void doSomething() {
        std::cout << "Singleton is doing something" << std::endl;
    }

    ~Singleton() {
        std::cout << "Singleton destroyed" << std::endl;
    }
};

int main() {
    Singleton& instance1 = Singleton::getInstance();
    instance1.doSomething();

    Singleton& instance2 = Singleton::getInstance();
    instance2.doSomething();

    if (&instance1 == &instance2) {
        std::cout << "Both instances are the same" << std::endl;
    }

    return 0;
}

登录后复制

这种方式更加简洁，并且依赖于C++标准的线程安全保证。