C++设计模式总结

Dontla2025-03-09 16:36

文章目录

      • 一、**创建型模式**（简化对象创建）
        • [1. **工厂模式**（Factory Pattern）](#1. 工厂模式（Factory Pattern）)
        • [2. **单例模式**（Singleton Pattern）](#2. 单例模式（Singleton Pattern）)
        • [3. **建造者模式**（Builder Pattern）](#3. 建造者模式（Builder Pattern）)
      • 二、**结构型模式**（处理对象组合关系）
        • [4. **适配器模式**（Adapter Pattern）](#4. 适配器模式（Adapter Pattern）)
        • [5. **组合模式**（Composite Pattern）](#5. 组合模式（Composite Pattern）)
        • [6. **代理模式**（Proxy Pattern - 如智能指针）](#6. 代理模式（Proxy Pattern - 如智能指针）)
      • 三、**行为型模式**（对象间的通信与职责分配）
        • [7. **观察者模式**（Observer Pattern）](#7. 观察者模式（Observer Pattern）)
        • [8. **策略模式**（Strategy Pattern）](#8. 策略模式（Strategy Pattern）)
        • [9. **模板方法模式**（Template Method）](#9. 模板方法模式（Template Method）)
      • [四、**C++ 特有模式**](#四、C++ 特有模式)
        • [10. **RAII 模式**（资源获取即初始化）](#10. RAII 模式（资源获取即初始化）)
        • [11. **CRTP 模式**（Curiously Recurring Template Pattern）](#11. CRTP 模式（Curiously Recurring Template Pattern）)
        • [12. **PIMPL 惯用法**（减少头文件依赖）](#12. PIMPL 惯用法（减少头文件依赖）)
      • 五、**性能优化模式**
        • [13. **对象池模式**（避免频繁创建销毁）](#13. 对象池模式（避免频繁创建销毁）)
        • [14. **惰性初始化模式**（延迟加载）](#14. 惰性初始化模式（延迟加载）)
      • **总结：何时选用哪些模式？**

C++ 中常用的设计模式与其独特语言特性（如手动内存管理、模板、运算符重载等）结合，可以简化复杂逻辑的代码实现，以下是 20 种核心设计模式（实际上不到20种） 及其典型 C++ 实现示例：

一、创建型模式（简化对象创建）

1. 工厂模式（Factory Pattern）

  • 作用：解耦对象的创建逻辑与使用逻辑

  • 代码示例 ：

    cpp 复制代码 
    class Shape {
public:
    virtual ~Shape() = default;
    virtual void draw() = 0;
};
class Circle : public Shape { /*...*/ };
class Square : public Shape { /*...*/ };

class ShapeFactory {
public:
    static Shape* createShape(const string& type) {
        if (type == "circle") return new Circle();
        else if (type == "square") return new Square();
        return nullptr;
    }
};

// 使用：
Shape* obj = ShapeFactory::createShape("circle");
obj->draw();
2. 单例模式（Singleton Pattern）

  • C++ 线程安全推荐实现 ：

    cpp 复制代码 
    class Singleton {
private:
    static Singleton* instance;
    static mutex mtx;
    Singleton() {} // 私有化构造函数

public:
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

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

// 初始化静态成员：
Singleton* Singleton::instance = nullptr;
mutex Singleton::mtx;
3. 建造者模式（Builder Pattern）

  • 适用场景 ：分步骤创建复杂对象（如 GUI 组件）

    cpp 复制代码 
    class Pizza {
public:
    void setDough(const string& dough) { /*...*/ }
    void setSauce(const string& sauce) { /*...*/ }
};

class PizzaBuilder {
public:
    virtual ~PizzaBuilder() = default;
    virtual void buildDough() = 0;
    virtual void buildSauce() = 0;
    virtual Pizza* getPizza() = 0;
};

class Chef {
private:
    PizzaBuilder* builder;
public:
    void makePizza(PizzaBuilder* b) {
        builder = b;
        b->buildDough();
        b->buildSauce();
    }
};

二、结构型模式（处理对象组合关系）

4. 适配器模式（Adapter Pattern）

  • 用途 ：转换接口以兼容旧代码

    cpp 复制代码 
    class LegacyRectangle { // 旧接口: 通过坐标画矩形
public:
    void draw(int x1, int y1, int x2, int y2) { /*...*/ }
};

class RectangleAdapter : public Shape {
private:
    LegacyRectangle adaptee;
public:
    void draw() override { 
        adaptee.draw(0, 0, 100, 100); // 适配到新接口
    }
};
5. 组合模式（Composite Pattern）

  • 树形结构示例 ：

    cpp 复制代码 
    class Component {
public:
    virtual ~Component() = default;
    virtual void operation() = 0;
    virtual void add(Component* c) {} // 默认空实现
};

class Leaf : public Component {
public:
    void operation() override { /*处理叶子节点*/ }
};

class Composite : public Component {
private:
    vector<Component*> children;
public:
    void operation() override {
        for (auto& child : children) {
            child->operation(); // 递归调用子节点
        }
    }
    void add(Component* c) override { children.push_back(c); }
};
6. 代理模式（Proxy Pattern - 如智能指针）

  • 通过 RAII 管理资源 ：

    cpp 复制代码 
    template <typename T>
class SmartPointer {
private:
    T* raw_ptr;
public:
    explicit SmartPointer(T* ptr) : raw_ptr(ptr) {}
    ~SmartPointer() { delete raw_ptr; }
    T* operator->() { return raw_ptr; } // 代理指针运算符
};

// 使用：
SmartPointer<MyClass> ptr(new MyClass());
ptr->doSomething(); // 自动释放内存

三、行为型模式（对象间的通信与职责分配）

7. 观察者模式（Observer Pattern）

  • 基于 C++11 的现代化实现 ：

    cpp 复制代码 
    #include <functional>
#include <vector>

class Subject {
private:
    vector<function<void(int)>> observers;
public:
    void attach(const function<void(int)>& obs) {
        observers.push_back(obs);
    }
    void notify(int value) {
        for (auto& obs : observers) {
            obs(value); // 通知所有观察者
        }
    }
};

// 使用 lambda：
Subject subject;
subject.attach([](int val) { cout << "Observer1: " << val << endl; });
subject.notify(42);
8. 策略模式（Strategy Pattern）

  • 结合模板与函数对象 ：

    cpp 复制代码 
    template <typename T>
class SortStrategy {
public:
    virtual void sort(vector<T>& data) = 0;
};

class QuickSort : public SortStrategy<int> {
public:
    void sort(vector<int>& data) override { /*快速排序实现*/ }
};

class Context {
private:
    SortStrategy<int>* strategy;
public:
    void setStrategy(SortStrategy<int>* s) { strategy = s; }
    void execute(vector<int>& data) { strategy->sort(data); }
};
9. 模板方法模式（Template Method）

  • 代码骨架延迟实现 ：

    cpp 复制代码 
    class DataProcessor {
public:
    void process() {
        loadData();
        analyze();     // 子类实现差异点
        saveResult();
    }
protected:
    virtual void analyze() = 0;
    void loadData() { /*通用加载逻辑*/ }
    void saveResult() { /*通用保存逻辑*/ }
};

class AudioProcessor : public DataProcessor {
protected:
    void analyze() override { /*音频分析算法*/ }
};

四、C++ 特有模式

10. RAII 模式（资源获取即初始化）

  • 核心思想 ：通过对象生命周期自动管理资源（内存、文件、锁）

    cpp 复制代码 
    class FileWrapper {
private:
    FILE* file;
public:
    explicit FileWrapper(const char* filename) : file(fopen(filename, "r")) {}
    ~FileWrapper() { if (file) fclose(file); }
    // 禁用拷贝（或实现移动语义）
    FileWrapper(const FileWrapper&) = delete;
    FileWrapper& operator=(const FileWrapper&) = delete;
};

// 使用：
{
    FileWrapper file("data.txt"); // 文件自动关闭
}
11. CRTP 模式（Curiously Recurring Template Pattern）

  • 静态多态优化性能 ：

    cpp 复制代码 
    template <typename Derived>
class Base {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

class Derived : public Base<Derived> {
public:
    void implementation() { /*子类具体实现*/ }
};

// 调用：
Derived d;
d.interface(); // 调用Derived的实现，无虚函数开销
12. PIMPL 惯用法（减少头文件依赖）

  • 隐藏实现细节 ：

    cpp 复制代码 
    // Widget.h
class Widget {
public:
    Widget();
    ~Widget();
    void doSomething();
private:
    struct Impl;  // 前向声明
    unique_ptr<Impl> pImpl; // 实现细节隐藏
};

// Widget.cpp
struct Widget::Impl {
    int internalData;
    void helperFunction() { /*私有函数实现*/ }
};

Widget::Widget() : pImpl(make_unique<Impl>()) {}
Widget::~Widget() = default; // 需在cpp中定义（因unique_ptr删除不完整类型）

五、性能优化模式

13. 对象池模式（避免频繁创建销毁）
cpp 复制代码 
template <typename T>
class ObjectPool {
private:
    queue<unique_ptr<T>> pool;
public:
    T* acquire() {
        if (pool.empty()) {
            return new T();
        }
        auto obj = std::move(pool.front());
        pool.pop();
        return obj.release();
    }
    void release(T* obj) {
        pool.push(unique_ptr<T>(obj)); // 重用对象
    }
};
14. 惰性初始化模式（延迟加载）
cpp 复制代码 
class HeavyResource {
private:
    vector<BigData>* data = nullptr;
public:
    vector<BigData>& getData() {
        if (data == nullptr) {
            data = new vector<BigData>(/*加载大量数据*/);
        }
        return *data;
    }
};

总结：何时选用哪些模式？

场景 推荐模式
需要隔离对象创建细节 工厂模式、建造者模式
全局唯一访问点配置 单例模式 (谨慎使用)
统一处理树形结构 组合模式
动态增减对象功能 装饰器模式
跨平台接口适配 适配器模式、桥接模式
事件驱动系统 观察者模式、发布-订阅模式
算法灵活替换 策略模式、模板方法模式

设计模式的本质是 代码结构的经验总结，根据具体需求灵活选用，切勿过度设计！

相关推荐
夏天的味道٥1 小时前
使用 Java 执行 SQL 语句和存储过程
java·开发语言·sql
IT、木易3 小时前
大白话JavaScript实现一个函数，将字符串中的每个单词首字母大写。
开发语言·前端·javascript·ecmascript
Mr.NickJJ3 小时前
JavaScript系列06-深入理解 JavaScript 事件系统：从原生事件到 React 合成事件
开发语言·javascript·react.js
Dream it possible！4 小时前
LeetCode 热题 100_字符串解码（71_394_中等_C++）（栈）
c++·算法·leetcode
Archer1945 小时前
C语言——链表
c语言·开发语言·链表
My Li.5 小时前
c++的介绍
开发语言·c++
功德+n5 小时前
Maven 使用指南：基础 + 进阶 + 高级用法
java·开发语言·maven
达斯维达的大眼睛5 小时前
qt小项目，简单的音乐播放器
开发语言·qt
面会菜.5 小时前
C语言（队列）
c语言·开发语言
香精煎鱼香翅捞饭5 小时前
java通用自研接口限流组件
java·开发语言
热门推荐
01DeepSeek各版本说明与优缺点分析02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03如何在WPS和Word/Excel中直接使用DeepSeek功能04苍穹外卖面试总结05DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具06本地部署DeepSeek教程（Mac版本）07Coze扣子平台完整体验和实践（附国内和国际版对比）08Windows 11 安装 Dify 完整指南 非docker环境09保姆级教程：利用Ollama与Open-WebUI本地部署 DeedSeek-R1大模型10macOS 上部署 RAGFlow