「C/C++」C++经验篇 之 类设计的可扩展能力

✨博客主页
何曾参静谧的博客（✅关注、👍点赞、⭐收藏、🎠转发）
📚全部专栏（专栏会有变化，以最新发布为准）
「Win」Windows程序设计	「IDE」集成开发环境	「定制」定制开发集合
「C/C++」C/C++程序设计	「DSA」数据结构与算法	「UG/NX」NX二次开发
「QT」QT5程序设计	「File」数据文件格式	「UG/NX」BlockUI集合
「Py」Python程序设计	「Math」探秘数学世界	「PK」Parasolid函数说明
「Web」前后端全栈开发	「En」英语从零到一	👍占位符
「AI」人工智能大模型	「书」书籍阅读笔记

在 C++ 软件开发中，设计具有 可扩展能力 的类是提高代码可维护性和适应未来需求变化的关键。以下是几种核心设计原则和模式，帮助你构建可扩展的类：

---

1. 遵循 SOLID 原则

SOLID 是面向对象设计的五大原则，直接影响类的可扩展性：

• S (Single Responsibility, 单一职责)
  每个类只负责一个功能，避免修改一个功能影响其他功能。

  // Bad: 一个类处理数据和日志
  class DataProcessor {
      void processData();
      void logData();  // 应该拆分到 Logger 类
  };
  
  // Good: 拆分成两个类
  class DataProcessor { void processData(); };
  class Logger { void logData(); };
  

• O (Open-Closed, 开闭原则)
  类应对扩展开放，对修改关闭。通过继承或组合扩展行为，而非直接修改源码。
  「C/C++」C++经验篇 之 开闭原则（Open-Closed Principle, OCP）

  // 通过抽象类扩展
  class Shape {
  public:
      virtual double area() const = 0;  // 子类可扩展
  };
  class Circle : public Shape { /* 实现 area() */ };
  

• L (Liskov Substitution, 里氏替换)
  子类必须能替换父类，避免破坏继承体系。

• I (Interface Segregation, 接口隔离)
  客户端不应依赖它不需要的接口。拆分臃肿接口。

  // Bad: 一个接口包含太多方法
  class IWorker {
      virtual void work() = 0;
      virtual void eat() = 0;  // 非所有子类需要
  };
  
  // Good: 拆分成两个接口
  class IWorkable { virtual void work() = 0; };
  class IEatable { virtual void eat() = 0; };
  

• D (Dependency Inversion, 依赖倒置)
  依赖抽象（接口），而非具体实现。

  class IStorage { virtual void save() = 0; };
  class Database : public IStorage { /* 实现 save() */ };
  class FileSystem : public IStorage { /* 实现 save() */ };
  
  class App {
      IStorage* storage;  // 依赖抽象
  public:
      App(IStorage* s) : storage(s) {}
  };
  

---

2. 使用设计模式

(1) 策略模式（Strategy）

将算法或行为抽象为接口，运行时动态替换。

class ISortStrategy {
public:
    virtual void sort(vector<int>& data) = 0;
};

class QuickSort : public ISortStrategy { /* 实现 */ };
class MergeSort : public ISortStrategy { /* 实现 */ };

class Sorter {
    ISortStrategy* strategy;
public:
    void setStrategy(ISortStrategy* s) { strategy = s; }
    void execute(vector<int>& data) { strategy->sort(data); }
};

(2) 装饰器模式（Decorator）

动态扩展对象功能，避免继承爆炸。

class IComponent {
public:
    virtual void operation() = 0;
};

class ConcreteComponent : public IComponent { /* 基础功能 */ };

class Decorator : public IComponent {
    IComponent* component;
public:
    Decorator(IComponent* c) : component(c) {}
    void operation() override { component->operation(); }
};

class LogDecorator : public Decorator {
public:
    void operation() override {
        Decorator::operation();
        cout << "Logging...";  // 扩展功能
    }
};

(3) 工厂模式（Factory）

封装对象创建逻辑，便于扩展新类型。

class IProduct {
public:
    virtual void use() = 0;
};

class ProductA : public IProduct { /* 实现 */ };
class ProductB : public IProduct { /* 实现 */ };

class Factory {
public:
    static IProduct* createProduct(const string& type) {
        if (type == "A") return new ProductA();
        if (type == "B") return new ProductB();
        return nullptr;
    }
};

---

3. 其他关键技巧

(1) 使用模板（泛型编程）

让类支持不同类型，避免重复代码。

template <typename T>
class Stack {
    vector<T> data;
public:
    void push(T item) { data.push_back(item); }
    T pop() { /* 实现 */ }
};

(2) Pimpl 惯用法（隐藏实现细节）

将实现移到 .cpp 文件中，减少头文件依赖。

// MyClass.h
class MyClass {
    class Impl;  // 前向声明
    unique_ptr<Impl> pimpl;
public:
    MyClass();
    void doSomething();
};

// MyClass.cpp
class MyClass::Impl { /* 具体实现 */ };
MyClass::MyClass() : pimpl(make_unique<Impl>()) {}
void MyClass::doSomething() { pimpl->doSomething(); }

(3) 事件/观察者模式

通过事件机制解耦类之间的依赖。

class IObserver {
public:
    virtual void update(const string& msg) = 0;
};

class Subject {
    vector<IObserver*> observers;
public:
    void attach(IObserver* obs) { observers.push_back(obs); }
    void notify(const string& msg) {
        for (auto obs : observers) obs->update(msg);
    }
};

---

4. 实际案例：可扩展的插件架构

// IPlugin.h
class IPlugin {
public:
    virtual string getName() = 0;
    virtual void execute() = 0;
};

// MainApp.cpp
vector<IPlugin*> plugins;

void loadPlugin(IPlugin* plugin) {
    plugins.push_back(plugin);
}

void runPlugins() {
    for (auto p : plugins) p->execute();
}

扩展方式：未来只需实现 IPlugin 接口并动态加载（如 DLL）。

---

总结：可扩展类的设计要点

方法	适用场景	示例
SOLID 原则	基础设计规范	单一职责、依赖抽象
设计模式	特定扩展需求	策略模式、装饰器模式
模板/Pimpl	减少代码冗余或隐藏实现	泛型容器、降低编译依赖
事件/插件机制	动态扩展行为	插件系统、消息通知

通过结合这些方法，你的 C++ 类可以轻松适应未来的需求变化，而无需大规模重构。

何曾参静谧的博客（✅关注、👍点赞、⭐收藏、🎠转发）

---