C++设计模式总结

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

---

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

1. 工厂模式（Factory Pattern）

• 作用：解耦对象的创建逻辑与使用逻辑
  
• 代码示例：
  1. class Shape {
  2. public:
  3.     virtual ~Shape() = default;
  4.     virtual void draw() = 0;
  5. };
  6. class Circle : public Shape { /*...*/ };
  7. class Square : public Shape { /*...*/ };
  9. class ShapeFactory {
  10. public:
  11.     static Shape* createShape(const string& type) {
  12.         if (type == "circle") return new Circle();
  13.         else if (type == "square") return new Square();
  14.         return nullptr;
  15.     }
  16. };
  18. // 使用：
  19. Shape* obj = ShapeFactory::createShape("circle");
  20. obj->draw();

  复制代码

2. 单例模式（Singleton Pattern）

• C++ 线程安全推荐实现：
  1. class Singleton {
  2. private:
  3.     static Singleton* instance;
  4.     static mutex mtx;
  5.     Singleton() {} // 私有化构造函数
  7. public:
  8.     Singleton(const Singleton&) = delete;
  9.     Singleton& operator=(const Singleton&) = delete;
  11.     static Singleton* getInstance() {
  12.         if (instance == nullptr) {
  13.             lock_guard<mutex> lock(mtx); // 加锁
  14.             if (instance == nullptr) {   // 双重检查锁定
  15.                 instance = new Singleton();
  16.             }
  17.         }
  18.         return instance;
  19.     }
  20. };
  22. // 初始化静态成员：
  23. Singleton* Singleton::instance = nullptr;
  24. mutex Singleton::mtx;

  复制代码

3. 建造者模式（Builder Pattern）

• 适用场景：分步骤创建复杂对象（如 GUI 组件）
  1. class Pizza {
  2. public:
  3.     void setDough(const string& dough) { /*...*/ }
  4.     void setSauce(const string& sauce) { /*...*/ }
  5. };
  7. class PizzaBuilder {
  8. public:
  9.     virtual ~PizzaBuilder() = default;
  10.     virtual void buildDough() = 0;
  11.     virtual void buildSauce() = 0;
  12.     virtual Pizza* getPizza() = 0;
  13. };
  15. class Chef {
  16. private:
  17.     PizzaBuilder* builder;
  18. public:
  19.     void makePizza(PizzaBuilder* b) {
  20.         builder = b;
  21.         b->buildDough();
  22.         b->buildSauce();
  23.     }
  24. };

  复制代码

---

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

4. 适配器模式（Adapter Pattern）

• 用途：转换接口以兼容旧代码
  1. class LegacyRectangle { // 旧接口: 通过坐标画矩形
  2. public:
  3.     void draw(int x1, int y1, int x2, int y2) { /*...*/ }
  4. };
  6. class RectangleAdapter : public Shape {
  7. private:
  8.     LegacyRectangle adaptee;
  9. public:
  10.     void draw() override {
  11.         adaptee.draw(0, 0, 100, 100); // 适配到新接口
  12.     }
  13. };

  复制代码

5. 组合模式（Composite Pattern）

• 树形结构示例：
  1. class Component {
  2. public:
  3.     virtual ~Component() = default;
  4.     virtual void operation() = 0;
  5.     virtual void add(Component* c) {} // 默认空实现
  6. };
  8. class Leaf : public Component {
  9. public:
  10.     void operation() override { /*处理叶子节点*/ }
  11. };
  13. class Composite : public Component {
  14. private:
  15.     vector<Component*> children;
  16. public:
  17.     void operation() override {
  18.         for (auto& child : children) {
  19.             child->operation(); // 递归调用子节点
  20.         }
  21.     }
  22.     void add(Component* c) override { children.push_back(c); }
  23. };

  复制代码

6. 代理模式（Proxy Pattern - 如智能指针）

• 通过 RAII 管理资源：
  1. template <typename T>
  2. class SmartPointer {
  3. private:
  4.     T* raw_ptr;
  5. public:
  6.     explicit SmartPointer(T* ptr) : raw_ptr(ptr) {}
  7.     ~SmartPointer() { delete raw_ptr; }
  8.     T* operator->() { return raw_ptr; } // 代理指针运算符
  9. };
  11. // 使用：
  12. SmartPointer<MyClass> ptr(new MyClass());
  13. ptr->doSomething(); // 自动释放内存

  复制代码

---

三、举动型模式（对象间的通讯与职责分配）

7. 观察者模式（Observer Pattern）

• 基于 C++11 的当代化实现：
  1. #include <functional>
  2. #include <vector>
  4. class Subject {
  5. private:
  6.     vector<function<void(int)>> observers;
  7. public:
  8.     void attach(const function<void(int)>& obs) {
  9.         observers.push_back(obs);
  10.     }
  11.     void notify(int value) {
  12.         for (auto& obs : observers) {
  13.             obs(value); // 通知所有观察者
  14.         }
  15.     }
  16. };
  18. // 使用 lambda：
  19. Subject subject;
  20. subject.attach([](int val) { cout << "Observer1: " << val << endl; });
  21. subject.notify(42);

  复制代码

8. 计谋模式（Strategy Pattern）

• 结合模板与函数对象：
  1. template <typename T>
  2. class SortStrategy {
  3. public:
  4.     virtual void sort(vector<T>& data) = 0;
  5. };
  7. class QuickSort : public SortStrategy<int> {
  8. public:
  9.     void sort(vector<int>& data) override { /*快速排序实现*/ }
  10. };
  12. class Context {
  13. private:
  14.     SortStrategy<int>* strategy;
  15. public:
  16.     void setStrategy(SortStrategy<int>* s) { strategy = s; }
  17.     void execute(vector<int>& data) { strategy->sort(data); }
  18. };

  复制代码

9. 模板方法模式（Template Method）

• 代码骨架延迟实现：
  1. class DataProcessor {
  2. public:
  3.     void process() {
  4.         loadData();
  5.         analyze();     // 子类实现差异点
  6.         saveResult();
  7.     }
  8. protected:
  9.     virtual void analyze() = 0;
  10.     void loadData() { /*通用加载逻辑*/ }
  11.     void saveResult() { /*通用保存逻辑*/ }
  12. };
  14. class AudioProcessor : public DataProcessor {
  15. protected:
  16.     void analyze() override { /*音频分析算法*/ }
  17. };

  复制代码

---

四、C++ 特有模式

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

• 核心头脑：通过对象生命周期主动管理资源（内存、文件、锁）
  1. class FileWrapper {
  2. private:
  3.     FILE* file;
  4. public:
  5.     explicit FileWrapper(const char* filename) : file(fopen(filename, "r")) {}
  6.     ~FileWrapper() { if (file) fclose(file); }
  7.     // 禁用拷贝（或实现移动语义）
  8.     FileWrapper(const FileWrapper&) = delete;
  9.     FileWrapper& operator=(const FileWrapper&) = delete;
  10. };
  12. // 使用：
  13. {
  14.     FileWrapper file("data.txt"); // 文件自动关闭
  15. }

  复制代码

11. CRTP 模式（Curiously Recurring Template Pattern）

• 静态多态优化性能：
  1. template <typename Derived>
  2. class Base {
  3. public:
  4.     void interface() {
  5.         static_cast<Derived*>(this)->implementation();
  6.     }
  7. };
  9. class Derived : public Base<Derived> {
  10. public:
  11.     void implementation() { /*子类具体实现*/ }
  12. };
  14. // 调用：
  15. Derived d;
  16. d.interface(); // 调用Derived的实现，无虚函数开销

  复制代码

12. PIMPL 惯用法（减少头文件依赖）

• 隐藏实现细节：
  1. // Widget.h
  2. class Widget {
  3. public:
  4.     Widget();
  5.     ~Widget();
  6.     void doSomething();
  7. private:
  8.     struct Impl;  // 前向声明
  9.     unique_ptr<Impl> pImpl; // 实现细节隐藏
  10. };
  12. // Widget.cpp
  13. struct Widget::Impl {
  14.     int internalData;
  15.     void helperFunction() { /*私有函数实现*/ }
  16. };
  18. Widget::Widget() : pImpl(make_unique<Impl>()) {}
  19. Widget::~Widget() = default; // 需在cpp中定义（因unique_ptr删除不完整类型）

  复制代码

---

五、性能优化模式

13. 对象池模式（制止频繁创建烧毁）

1. template <typename T>
2. class ObjectPool {
3. private:
4.     queue<unique_ptr<T>> pool;
5. public:
6.     T* acquire() {
7.         if (pool.empty()) {
8.             return new T();
9.         }
10.         auto obj = std::move(pool.front());
11.         pool.pop();
12.         return obj.release();
13.     }
14.     void release(T* obj) {
15.         pool.push(unique_ptr<T>(obj)); // 重用对象
16.     }
17. };

复制代码

14. 惰性初始化模式（延迟加载）

1. class HeavyResource {
2. private:
3.     vector<BigData>* data = nullptr;
4. public:
5.     vector<BigData>& getData() {
6.         if (data == nullptr) {
7.             data = new vector<BigData>(/*加载大量数据*/);
8.         }
9.         return *data;
10.     }
11. };

复制代码

---

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

场景推荐模式需要隔离对象创建细节工厂模式、建造者模式全局唯一访问点设置单例模式 (谨慎使用)统一处置惩罚树形结构组合模式动态增减对象功能装饰器模式跨平台接口适配适配器模式、桥接模式事件驱动系统观察者模式、发布-订阅模式算法机动替换计谋模式、模板方法模式 设计模式的本质是 代码结构的经验总结，根据具体需求机动选用，切勿过分设计！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。