C++ SOLID 原则学习笔记

1. SRP:单一职责原则 (Single Responsibility Principle)

原则:一个类应该只有一个引起它变化的原因(即只做一件事)。

反例 上帝类 (God Class)

一个 VM 类既负责执行指令,又负责文件 IO,还负责格式化输出日志。

cpp 复制代码
class VM {
public:
    void Run(const char* bytecode);  // 核心业务
    void LoadFile(const std::string& path); // IO 职责
    void LogError(const std::string& msg);  // 日志/UI 职责
};

问题:如果我想改日志格式,得改 VM;如果我想改文件读取方式,也得改 VM。VM 类会变得极其臃肿。

正例 职责分离

将辅助功能剥离,VM 只关注核心的"执行"。

cpp 复制代码
// 1. Loader 负责加载
class ProgramLoader {
public:
    std::vector<uint8_t> Load(const std::string& path);
};

// 2. Logger 负责日志
class Logger {
public:
    void Log(const std::string& msg);
};

// 3. VM 只负责执行
class VM {
public:
    void Run(const std::vector<uint8_t>& code);
};

实战思考 :在 cilly-vm-cpp 中,StackStats 就是一个很好的 SRP 实践------它把栈统计逻辑从 VM 中剥离了出来。


2. OCP:开闭原则 (Open/Closed Principle)

原则 :软件实体(类、模块、函数)应该对扩展开放,对修改关闭 。 核心 :加新功能时,最好只加新代码 ,而不是改旧代码。

反例 Switch 满天飞

在 AST 处理中,使用 enum 和 switch 是最容易违反 OCP 的地方。

cpp 复制代码
enum class ExprKind { kAdd, kSub };

void Evaluate(Expr* expr) {
    switch (expr->kind) {
        case kAdd: /* ... */ break;
        case kSub: /* ... */ break;
        // 每次加新类型 kMul,都要来这里改代码!
    }
}

正例 访问者模式 (Visitor Pattern)

利用多态和双分派,将操作抽象为 Visitor。

cpp 复制代码
// 1. 定义访问者接口
class ExprVisitor {
public:
    virtual void Visit(class AddExpr* expr) = 0;
    virtual void Visit(class SubExpr* expr) = 0;
};

// 2. 元素基类接受访问者
struct Expr {
    virtual void Accept(ExprVisitor& v) = 0;
};

// 3. 具体元素实现 Accept
struct AddExpr : Expr {
    void Accept(ExprVisitor& v) override { v.Visit(this); }
};

// 4. 扩展功能:只需新增 Visitor,无需改动 Expr 类
class Printer : public ExprVisitor {
    void Visit(AddExpr* expr) override { std::cout << "+"; }
    void Visit(SubExpr* expr) override { std::cout << "-"; }
};

3. LSP:里氏替换原则 (Liskov Substitution Principle)

原则 :子类对象必须能够替换掉所有父类对象,而不会导致程序错误。 通俗理解 :父类能用的地方,换成子类也能用,且不会炸。

反例 正方形不是长方形

cpp 复制代码
class Rectangle {
public:
    virtual void SetWidth(int w) { width_ = w; }
    virtual void SetHeight(int h) { height_ = h; }
    int Area() const { return width_ * height_; }
protected:
    int width_, height_;
};

class Square : public Rectangle {
public:
    // 破坏了父类的语义:设置宽会导致高也变化
    void SetWidth(int w) override { width_ = height_ = w; }
    void SetHeight(int h) override { width_ = height_ = h; }
};

void Resize(Rectangle& r) {
    r.SetWidth(5);
    r.SetHeight(4);
    assert(r.Area() == 20); // 传入 Square 时,这里会断言失败(结果是 16)
}

正例 GC 对象契约

在 GC 系统中,所有对象都继承自 GcObject。

cpp 复制代码
class GcObject {
public:
    // 契约:子类必须在这个函数里报告它引用的所有子对象
    virtual void Trace(Collector& c) = 0;
};

// 只要 StringObject 正确实现了 Trace(哪怕它是空的),
// 它就能被 Collector 正确处理,不会导致 GC 崩溃。
class StringObject : public GcObject {
    void Trace(Collector& c) override { /* 无引用,空实现即可 */ }
};

4. ISP:接口隔离原则 (Interface Segregation Principle)

原则 :客户端不应该依赖它不需要的接口。 核心 :接口要小而专,避免大而全。

反例 胖接口

cpp 复制代码
class ISmartObject {
public:
    virtual void Serialize() = 0; // 序列化
    virtual void Trace() = 0;     // GC 标记
    virtual void Draw() = 0;      // UI 绘制
};

// 仅仅是一个简单的数据对象,却被迫实现 Draw()
class DataNode : public ISmartObject {
    void Serialize() override { ... }
    void Trace() override { ... }
    void Draw() override { /* 抛异常或空实现 */ } // 违反 ISP
};

正例 接口拆分

cpp 复制代码
class ISerializable { virtual void Serialize() = 0; };
class IGcTraceable { virtual void Trace() = 0; };
class IDrawable { virtual void Draw() = 0; };

// 按需组合
class DataNode : public ISerializable, public IGcTraceable { ... };
class UiNode : public IDrawable, public IGcTraceable { ... };

5. DIP:依赖倒置原则 (Dependency Inversion Principle)

原则 :高层模块不应该依赖低层模块,二者都应该依赖其抽象。 核心 :面向接口编程。

反例 依赖具体实现

VM 直接依赖具体的标记清除 GC (MarkSweepCollector)。

cpp 复制代码
class MarkSweepCollector { ... };

class VM {
    MarkSweepCollector gc_; // 强耦合!
public:
    VM() { ... }
};

如果我想换成引用计数 GC (RefCountCollector),必须修改 VM 类的定义。

正例 依赖抽象接口

cpp 复制代码
// 1. 定义抽象接口
class IGcCollector {
public:
    virtual void Collect() = 0;
    virtual ~IGcCollector() = default;
};

// 2. VM 依赖接口
class VM {
    IGcCollector* gc_; 
public:
    // 3. 通过构造函数注入具体实现
    VM(IGcCollector* gc) : gc_(gc) {}
};

// 4. 外部决定用哪种 GC
int main() {
    MarkSweepCollector my_gc;
    VM vm(&my_gc); 
    // 或者 VM vm(new CopyingCollector());
}

总结

  • SRP: 一个类只做一件事。
  • OCP: 多态是关键,加新功能不改旧代码。
  • LSP: 子类必须能完全替代父类(行为不缩水、不捣乱)。
  • ISP: 接口要小,不要强迫子类实现没用的方法。
  • DIP: 依赖抽象接口,方便替换底层实现。
相关推荐
一拳一个呆瓜1 小时前
【STL】头文件:<cmath>
c++·stl
草莓熊Lotso2 小时前
【C++ 基于微服务的即时通讯系统】ElasticSearch 用户数据管理实现
linux·数据库·c++·elasticsearch·微服务·架构
慧都产品智能化2 小时前
Qt 开发 CAD/CAM 工序表的隐性成本分析
c++·qt·qt5·qt6.3
eggwyw4 小时前
linux下的C\C++多进程多线程编程实例详解
开发语言·c++
青少儿编程课堂5 小时前
第十八届蓝桥杯青少组图形化真题 + 全国青少年信息素养大赛 + 电子学会图形化考级:校园泡泡堂大挑战解析
c++·python·算法·bfs·信息学竞赛
小七在进步6 小时前
string的实现(3)
开发语言·c++·笔记·visual studio
青少儿编程课堂6 小时前
蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级:Dinic最大流解析
c++·python·算法·bfs·信息学竞赛
草莓熊Lotso7 小时前
【C++ 基于微服务的即时通讯系统】用户服务之Redis数据层落地:会话、登录状态与验证码全封装
数据库·c++·redis·微服务·语音识别
西西弗Sisyphus8 小时前
C++ 里 两个独立的所有权域之间没有建立同步的问题
c++
个 人 练 习 生18 小时前
C++:从零基础到深入了解vector的使用
开发语言·c++·经验分享·学习·程序人生·stl