C++单例模式教学指南

news2025/6/8 0:21:52

C++单例模式完整教学指南

📚 目录

  1. [单例模式基础概念]
  2. [经典单例实现及问题]
  3. [现代C++推荐实现]
  4. [高级话题：双重检查锁]
  5. [实战应用与最佳实践]
  6. [总结与选择指南]

1. 单例模式基础概念

1.1 什么是单例模式？

单例模式（Singleton Pattern）是一种创建型设计模式，确保一个类只有一个实例，并提供全局访问点。

1.2 应用场景

  • 日志系统：全局统一的日志记录器
  • 配置管理：程序配置信息的统一管理
  • 数据库连接池：管理数据库连接资源
  • 线程池：管理线程资源
  • 缓存系统：全局数据缓存

1.3 单例模式的核心要求

  • ✅ 只能有一个实例
  • ✅ 提供全局访问点
  • ❌ 禁止拷贝构造
  • ❌ 禁止赋值操作
  • ⚡ 线程安全（多线程环境）

2. 经典单例实现及问题

2.1 朴素实现（❌ 有问题）

class Singleton {
private:
    static Singleton* instance;
    Singleton() = default;
    
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();  // 线程不安全！
        }
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;

问题分析：

  • ❌ 线程不安全：多线程可能创建多个实例
  • ❌ 内存泄漏：new出来的对象永远不会被delete
  • ❌ 没有禁止拷贝和赋值

2.2 加锁版本（✅ 安全但性能差）

class Singleton {
private:
    static Singleton* instance;
    static std::mutex mtx;
    Singleton() = default;
    
public:
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
    static Singleton* getInstance() {
        std::lock_guard<std::mutex> lock(mtx);  // 每次都加锁，性能差
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};

Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mtx;

改进点：

  • ✅ 线程安全
  • ✅ 禁止拷贝和赋值
  • ❌ 性能问题：每次调用都要加锁
  • ❌ 仍有内存泄漏

3. 现代C++推荐实现

3.1 Meyers单例（⭐ 最推荐）

class Singleton {
private:
    Singleton() = default;
    ~Singleton() = default;
    
public:
    // 禁止拷贝和赋值
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
    static Singleton& getInstance() {
        static Singleton instance;  // C++11起线程安全
        return instance;
    }
    
    // 示例方法
    void doSomething() {
        std::cout << "Singleton working..." << std::endl;
    }
};

优势分析：

  • ✅ 线程安全：C++11保证局部静态变量初始化的线程安全性
  • ✅ 性能优秀：初始化后调用无需加锁
  • ✅ 自动析构：程序结束时自动清理
  • ✅ 代码简洁：无需手动管理内存和锁

3.2 通用单例模板（⭐ 可复用）

template <typename T>
class Singleton {
public:
    // 禁止拷贝和赋值
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
    static T& getInstance() {
        static T instance;
        return instance;
    }
    
protected:
    Singleton() = default;
    ~Singleton() = default;
};

// 使用示例
class Logger : public Singleton<Logger> {
    friend class Singleton<Logger>;  // 允许Singleton访问私有构造函数
    
private:
    Logger() { 
        std::cout << "Logger initialized" << std::endl; 
    }
    
public:
    void log(const std::string& message) {
        std::cout << "[LOG] " << message << std::endl;
    }
};

// 使用方法
int main() {
    Logger::getInstance().log("Hello Singleton!");
    return 0;
}

4. 高级话题：双重检查锁

4.1 什么是双重检查锁（DCLP）？

双重检查锁定（Double-Checked Locking Pattern）是一种优化技术，减少锁的使用频率：

if (!instance) {           // 第一次检查（无锁）
    std::lock_guard<std::mutex> lock(mtx);
    if (!instance) {       // 第二次检查（加锁后）
        instance = new Singleton();
    }
}

4.2 传统DCLP的问题

class UnsafeSingleton {
private:
    static std::shared_ptr<UnsafeSingleton> instance;
    static std::mutex mtx;
    
public:
    static std::shared_ptr<UnsafeSingleton> getInstance() {
        if (!instance) {  // 问题：可能读到"半成品"对象
            std::lock_guard<std::mutex> lock(mtx);
            if (!instance) {
                instance = std::make_shared<UnsafeSingleton>();  // 非原子操作
            }
        }
        return instance;
    }
};

问题根源： std::make_shared的执行过程不是原子的：

  1. 分配内存
  2. 调用构造函数
  3. 设置指针值

其他线程可能在步骤2和3之间读到未完全构造的对象！

4.3 安全的DCLP实现

template <typename T>
class SafeDCLPSingleton {
private:
    static std::atomic<std::shared_ptr<T>> instance;
    static std::mutex mtx;
    
protected:
    SafeDCLPSingleton() = default;
    ~SafeDCLPSingleton() = default;
    
public:
    SafeDCLPSingleton(const SafeDCLPSingleton&) = delete;
    SafeDCLPSingleton& operator=(const SafeDCLPSingleton&) = delete;
    
    static std::shared_ptr<T> getInstance() {
        // 原子读取
        auto temp = instance.load(std::memory_order_acquire);
        if (!temp) {
            std::lock_guard<std::mutex> lock(mtx);
            temp = instance.load(std::memory_order_relaxed);
            if (!temp) {
                temp = std::make_shared<T>();
                // 原子写入
                instance.store(temp, std::memory_order_release);
            }
        }
        return temp;
    }
};

// 静态成员定义
template <typename T>
std::atomic<std::shared_ptr<T>> SafeDCLPSingleton<T>::instance{nullptr};

template <typename T>
std::mutex SafeDCLPSingleton<T>::mtx;

5. 实战应用与最佳实践

5.1 日志系统实现

class Logger : public Singleton<Logger> {
    friend class Singleton<Logger>;
    
private:
    std::mutex log_mtx;
    std::ofstream log_file;
    
    Logger() {
        log_file.open("application.log", std::ios::app);
    }
    
    ~Logger() {
        if (log_file.is_open()) {
            log_file.close();
        }
    }
    
public:
    enum LogLevel { INFO, WARNING, ERROR };
    
    void log(LogLevel level, const std::string& message) {
        std::lock_guard<std::mutex> lock(log_mtx);
        
        auto now = std::chrono::system_clock::now();
        auto time_t = std::chrono::system_clock::to_time_t(now);
        
        log_file << "[" << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S") << "] ";
        
        switch (level) {
            case INFO: log_file << "[INFO] "; break;
            case WARNING: log_file << "[WARN] "; break;
            case ERROR: log_file << "[ERROR] "; break;
        }
        
        log_file << message << std::endl;
        log_file.flush();
    }
};

// 使用示例
int main() {
    Logger::getInstance().log(Logger::INFO, "Application started");
    Logger::getInstance().log(Logger::ERROR, "Something went wrong");
    return 0;
}

5.2 配置管理器

class ConfigManager : public Singleton<ConfigManager> {
    friend class Singleton<ConfigManager>;
    
private:
    std::unordered_map<std::string, std::string> config_data;
    mutable std::shared_mutex config_mtx;
    
    ConfigManager() {
        loadFromFile("config.ini");
    }
    
    void loadFromFile(const std::string& filename) {
        // 简化的配置文件加载逻辑
        config_data["database_url"] = "localhost:3306";
        config_data["max_connections"] = "100";
        config_data["debug_mode"] = "true";
    }
    
public:
    std::string getValue(const std::string& key, const std::string& default_value = "") const {
        std::shared_lock<std::shared_mutex> lock(config_mtx);
        auto it = config_data.find(key);
        return (it != config_data.end()) ? it->second : default_value;
    }
    
    void setValue(const std::string& key, const std::string& value) {
        std::unique_lock<std::shared_mutex> lock(config_mtx);
        config_data[key] = value;
    }
    
    int getIntValue(const std::string& key, int default_value = 0) const {
        std::string str_value = getValue(key);
        return str_value.empty() ? default_value : std::stoi(str_value);
    }
    
    bool getBoolValue(const std::string& key, bool default_value = false) const {
        std::string str_value = getValue(key);
        return str_value == "true" || str_value == "1";
    }
};

5.3 永不销毁的单例（特殊场景）

template <typename T>
class NeverDestroySingleton {
public:
    NeverDestroySingleton(const NeverDestroySingleton&) = delete;
    NeverDestroySingleton& operator=(const NeverDestroySingleton&) = delete;
    
    static T& getInstance() {
        static T* instance = new T();  // 永远不会被析构
        return *instance;
    }
    
protected:
    NeverDestroySingleton() = default;
    ~NeverDestroySingleton() = default;
};

使用场景：

  • 防止静态析构顺序问题
  • 程序退出时必须保持可用的组件（如日志系统）

注意： 这种方式会导致内存"泄漏"，但在某些场景下是可接受的。

6. 总结与选择指南

6.1 各种实现方式对比

实现方式线程安全性能内存管理复杂度推荐指数
朴素实现❌⭐⭐⭐⭐⭐❌⭐❌
加锁版本✅⭐⭐❌⭐⭐❌
Meyers单例✅⭐⭐⭐⭐⭐✅⭐⭐⭐⭐⭐⭐
单例模板✅⭐⭐⭐⭐⭐✅⭐⭐⭐⭐⭐⭐⭐
安全DCLP✅⭐⭐⭐⭐✅⭐⭐⭐⭐⭐⭐⭐

6.2 选择建议

🎯 通用场景（90%的情况）

推荐：Meyers单例或单例模板

class MyClass : public Singleton<MyClass> {
    friend class Singleton<MyClass>;
    // 实现...
};
🎯 高并发系统

推荐：安全DCLP + atomic

  • 网络服务器
  • 游戏引擎
  • 实时系统
🎯 特殊需求
  • 需要延迟销毁：NeverDestroy单例
  • 需要Mock测试：依赖注入替代单例
  • 跨DLL使用：特殊处理或避免使用

6.3 使用注意事项

✅ 最佳实践
  1. 优先使用Meyers单例（局部静态变量）
  2. 总是禁止拷贝构造和赋值操作
  3. 考虑使用模板提高代码复用性
  4. 在构造函数中完成所有初始化工作
  5. 注意异常安全性
❌ 常见误区
  1. 不要手动管理单例的生命周期
  2. 不要在单例的析构函数中访问其他单例
  3. 避免在单例中使用其他单例（循环依赖）
  4. 不要将单例用作全局变量的替代品

6.4 代码模板（直接使用）

// 文件：singleton.h
#pragma once
#include <mutex>
#include <memory>

// 通用单例模板
template <typename T>
class Singleton {
public:
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    Singleton(Singleton&&) = delete;
    Singleton& operator=(Singleton&&) = delete;
    
    static T& getInstance() {
        static T instance;
        return instance;
    }
    
protected:
    Singleton() = default;
    virtual ~Singleton() = default;
};

// 使用宏简化定义（可选）
#define SINGLETON_CLASS(ClassName) \
    friend class Singleton<ClassName>; \
    private: \
        ClassName(); \
        ~ClassName() = default;

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2403514.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

SOC-ESP32S3部分：31-ESP-LCD控制器库

SOC-ESP32S3部分：31-ESP-LCD控制器库

飞书文档https://x509p6c8to.feishu.cn/wiki/Syy3wsqHLiIiQJkC6PucEJ7Snib ESP 系列芯片可以支持市场上常见的 LCD&#xff08;如 SPI LCD、I2C LCD、并行 LCD (Intel 8080)、RGB/SRGB LCD、MIPI DSI LCD 等&#xff09;所需的各种时序。esp_lcd 控制器为上述各类 LCD 提供了一…
阅读更多...
【云安全】以Aliyun为例聊云厂商服务常见利用手段

【云安全】以Aliyun为例聊云厂商服务常见利用手段

目录 OSS-bucket_policy_readable OSS-object_public_access OSS-bucket_object_traversal OSS-Special Bucket Policy OSS-unrestricted_file_upload OSS-object_acl_writable ECS-SSRF 云攻防场景下对云厂商服务的利用大同小异&#xff0c;下面以阿里云为例 其他如腾…
阅读更多...
读文献先读图：GO弦图怎么看？

读文献先读图：GO弦图怎么看？

GO弦图&#xff08;Gene Ontology Chord Diagram&#xff09;是一种用于展示基因功能富集结果的可视化工具&#xff0c;通过弦状连接可以更直观的展示基因与GO term&#xff08;如生物过程、分子功能等&#xff09;之间的关联。 GO弦图解读 ①内圈连线表示基因和生物过程之间的…
阅读更多...
怎么让大语言模型（LLMs）自动生成和优化提示词：APE

怎么让大语言模型（LLMs）自动生成和优化提示词：APE

怎么让大语言模型（LLMs）自动生成和优化提示词：APE https://arxiv.org/pdf/2211.01910 1. 研究目标：让机器自己学会设计提示词 问题：大语言模型（如GPT-3）很强大，但需要精心设计的“提示词”才能发挥最佳效果。过去靠人工设计提示词，费时费力，还可能因表述差异导致模…
阅读更多...
实现单例模式的常见方式

实现单例模式的常见方式

前言 java有多种设计模式&#xff0c;如下图所示&#xff1a; 单例模式它确保一个类只有一个实例&#xff0c;并提供一个全局访问点。 1、单例模式介绍 1.1、使用原因 为什么要使用单例模式&#xff1f; 1. 控制资源访问 核心价值&#xff1a;确保对共享资源&#xff08;如…
阅读更多...
day20 leetcode-hot100-38（二叉树3）

day20 leetcode-hot100-38（二叉树3）

226. 翻转二叉树 - 力扣&#xff08;LeetCode&#xff09; 1.广度遍历 思路 这题目很简单&#xff0c;就是交换每个节点的左右子树&#xff0c;也就是相当于遍历到某个节点&#xff0c;然后交换子节点即可。 具体步骤 &#xff08;1&#xff09;创建队列&#xff0c;使用广…
阅读更多...
OpenVINO环境配置--OpenVINO安装

OpenVINO环境配置--OpenVINO安装

TOC环境配置–OpenVINO安装 本节内容 OpenVINO 支持的安装方式有很多种&#xff0c;每一种操作系统以及语言都有对应的安装方法&#xff0c;在官网上有很详细的教程&#xff1a;   我们可以根据自己的需要&#xff0c;来点选环境配置和安装方法&#xff0c;然后网页会给出正…
阅读更多...
黑龙江云前沿服务器租用：便捷高效的灵活之选​

黑龙江云前沿服务器租用：便捷高效的灵活之选​

服务器租用&#xff0c;即企业直接从互联网数据中心&#xff08;IDC&#xff09;提供商处租赁服务器。企业只需按照所选的服务器配置和租赁期限&#xff0c;定期支付租金&#xff0c;即可使用服务器开展业务。​ 便捷快速部署&#xff1a;租用服务器能极大地缩短服务器搭建周期…
阅读更多...
论文解读：Locating and Editing Factual Associations in GPT（ROME）

论文解读：Locating and Editing Factual Associations in GPT（ROME）

论文发表于人工智能顶会NeurIPS(原文链接)&#xff0c;研究了GPT(Generative Pre-trained Transformer)中事实关联的存储和回忆&#xff0c;发现这些关联与局部化、可直接编辑的计算相对应。因此&#xff1a; 1、开发了一种因果干预方法&#xff0c;用于识别对模型的事实预测起…
阅读更多...
学习设计模式《十二》——命令模式

学习设计模式《十二》——命令模式

一、基础概念 命令模式的本质是【封装请求】命令模式的关键是把请求封装成为命令对象&#xff0c;然后就可以对这个命令对象进行一系列的处理&#xff08;如&#xff1a;参数化配置、可撤销操作、宏命令、队列请求、日志请求等&#xff09;。 命令模式的定义&#xff1a;将一个…
阅读更多...
十三、【核心功能篇】测试计划管理：组织和编排测试用例

十三、【核心功能篇】测试计划管理：组织和编排测试用例

【核心功能篇】测试计划管理&#xff1a;组织和编排测试用例 前言准备工作第一部分&#xff1a;后端实现 (Django)1. 定义 TestPlan 模型2. 生成并应用数据库迁移3. 创建 TestPlanSerializer4. 创建 TestPlanViewSet5. 注册路由6. 注册到 Django Admin 第二部分&#xff1a;前端…
阅读更多...
手撕 K-Means

手撕 K-Means

1. K-means 的原理 K-means 是一种经典的无监督学习算法&#xff0c;用于将数据集划分为 kk 个簇&#xff08;cluster&#xff09;。其核心思想是通过迭代优化&#xff0c;将数据点分配到最近的簇中心&#xff0c;并更新簇中心&#xff0c;直到簇中心不再变化或达到最大迭代次…
阅读更多...
SmolVLA: 让机器人更懂 “看听说做” 的轻量化解决方案

SmolVLA: 让机器人更懂 “看听说做” 的轻量化解决方案

&#x1f9ed; TL;DR 今天&#xff0c;我们希望向大家介绍一个新的模型: SmolVLA&#xff0c;这是一个轻量级 (450M 参数) 的开源视觉 - 语言 - 动作 (VLA) 模型&#xff0c;专为机器人领域设计&#xff0c;并且可以在消费级硬件上运行。 SmolVLAhttps://hf.co/lerobot/smolvla…
阅读更多...
day45python打卡

day45python打卡

知识点回顾&#xff1a; tensorboard的发展历史和原理tensorboard的常见操作tensorboard在cifar上的实战&#xff1a;MLP和CNN模型 效果展示如下&#xff0c;很适合拿去组会汇报撑页数&#xff1a; 作业&#xff1a;对resnet18在cifar10上采用微调策略下&#xff0c;用tensorbo…
阅读更多...
AIGC赋能前端开发

AIGC赋能前端开发

一、引言&#xff1a;AIGC对前端开发的影响 1. AIGC与前端开发的关系 从“写代码”到“生成代码”传统开发痛点&#xff1a;重复性编码工作、UI 设计稿还原、问题定位与调试...核心场景的AI化&#xff1a;需求转代码&#xff08;P2C&#xff09;、设计稿转代码&#xff08;D2…
阅读更多...
Web 3D协作平台开发案例：构建制造业远程设计与可视化协作

Web 3D协作平台开发案例：构建制造业远程设计与可视化协作

HOOPS Communicator为开发者提供了丰富的定制化能力&#xff0c;助力他们在实现强大 Web 3D 可视化功能的同时&#xff0c;灵活构建符合特定业务需求的工程应用。对于希望构建在线协同设计工具的企业而言&#xff0c;如何在保障性能与用户体验的前提下实现高效开发&#xff0c;…
阅读更多...
AI Agent开发第78课-大模型结合Flink构建政务类长公文、长文件、OA应用Agent

AI Agent开发第78课-大模型结合Flink构建政务类长公文、长文件、OA应用Agent

开篇 AI Agent2025确定是进入了爆发期，到处都在冒出各种各样的实用AI Agent。很多人、组织都投身于开发AI Agent。 但是从3月份开始业界开始出现了一种这样的声音： AI开发入门并不难，一旦开发完后没法用！ 经历过至少一个AI Agent从开发到上线的小伙伴们其实都听到过这种…
阅读更多...
第三方测试机构进行科技成果鉴定测试有什么价值

第三方测试机构进行科技成果鉴定测试有什么价值

在当今科技创新的浪潮中&#xff0c;科技成果的鉴定测试至关重要&#xff0c;而第三方测试机构凭借其独特优势&#xff0c;在这一领域发挥着不可替代的作用。那么&#xff0c;第三方测试机构进行科技成果鉴定测试究竟有什么价值呢&#xff1f; 一、第三方测试机构能提供独立、公…
阅读更多...
华为云Flexus+DeepSeek征文｜基于华为云Flexus X和DeepSeek-R1打造个人知识库问答系统

华为云Flexus+DeepSeek征文｜基于华为云Flexus X和DeepSeek-R1打造个人知识库问答系统

目录 前言 1 快速部署&#xff1a;一键搭建Dify平台 1.1 部署流程详解 1.2 初始配置与登录 2 构建专属知识库 2.1 进入知识库模块并创建新库 2.2 选择数据源导入内容 2.3 上传并识别多种文档格式 2.4 文本处理与索引构建 2.5 保存并完成知识库创建 3接入ModelArts S…
阅读更多...
【数据结构】_排序

【数据结构】_排序

【本节目标】 排序的概念及其运用常见排序算法的实现排序算法复杂度及稳定性分析 1.排序的概念及其运用 1.1排序的概念 排序&#xff1a;所谓排序&#xff0c;就是使一串记录&#xff0c;按照其中的某个或某些关键字的大小&#xff0c;递增或递减的排列起来的操作。 1.2特性…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023