C++面试题_12_SOLID原则

原创已于 2025-11-13 10:32:00 修改 · 525 阅读

17 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #开发语言

于 2025-11-13 08:50:04 首次发布

c/c++ 语言面试专栏收录该内容

18 篇文章

订阅专栏

SOLID 原则（面向对象设计的五条基本准则）

SOLID 是面向对象设计的五条原则组合，有助于提高代码可维护性、可扩展性与可测试性。每条原则都简短明确 —— 下面逐条说明并给出简洁的 C++ 风格示例与常见陷阱。

S — Single Responsibility Principle（单一职责原则）

一句话：一个类应该只有一个引起它变化的原因。
要点：把不同关注点分离到不同类里，避免“上帝类”。

// 坏：Logger 和数据访问混在一起
class UserRepository {
public:
User getUser(int id);
void log(const std::string& msg); // 不属于仓库职责
};

// 好：职责分离
class Logger { public: void log(const std::string&); };
class UserRepository {
Logger& logger;
public:
UserRepository(Logger& l): logger(l) {}
User getUser(int id) { logger.log("getUser"); /*...*/ }
};

常见陷阱：把 UI、业务、持久化、日志等职责堆到一个类里。

O — Open/Closed Principle（开闭原则）

一句话：对扩展开放，对修改关闭 — 新需求通过扩展（继承/组合/策略）实现，而不是改现有代码。
要点：使用抽象接口与多态，避免修改现有类来添加新行为。

struct Shape { virtual double area() const = 0; };
struct Circle : Shape { double r; double area() const override { return 3.14*r*r; } };
struct Rectangle : Shape { double w,h; double area() const override { return w*h; } };

double totalArea(const std::vector<Shape*>& shapes){
double sum=0; for(auto s: shapes) sum += s->area();
return sum;
}
// 新增 Triangle 不改 totalArea，符合开闭
常见陷阱：直接在已有类中增加 if/else 分支来处理新类型。

L — Liskov Substitution Principle（里氏替换原则）

一句话：子类应能替换父类且不破坏程序正确性。
要点：子类不能违反父类的契约（行为/前置后置条件、异常语义等）。

class Bird { public: virtual void fly() {} };
class Ostrich : public Bird {
// 如果父类假定所有 Bird 都能 fly，Ostrich 就破坏了这个契约
void fly() override { throw std::runtime_error("can't fly"); }
};
应对方法：重构抽象（把可飞行为抽成 IFlyable 接口），或重新设计继承层次。

I — Interface Segregation Principle（接口隔离原则）

一句话：客户端不应被迫依赖它不使用的方法 —— 用多个小接口替代大接口。
要点：把“胖接口”拆成更小的、角色相关的接口。

struct IPrinter { virtual void print() = 0; virtual void scan() = 0; };
// 若有只打印的设备，被迫实现 scan 就违背了 ISP

struct IPrinter { virtual void print() = 0; };
struct IScanner { virtual void scan() = 0; };

D — Dependency Inversion Principle（依赖倒置原则）

一句话：高层模块不应该依赖低层模块，二者都应该依赖抽象（接口）；抽象不应依赖细节，细节应依赖抽象。
要点：通过接口和依赖注入（构造注入/工厂）解耦实现细节。

struct IMessageSender { virtual void send(const std::string&)=0; };
class EmailSender : public IMessageSender { void send(const std::string& m) override {/*...*/} };

class Notification {
IMessageSender& sender;
public:
Notification(IMessageSender& s): sender(s) {}
void notify(const std::string& msg) { sender.send(msg); }
};
// Notification 只依赖 IMessageSender（抽象），不依赖 EmailSender（细节）