1. 观察者模式 (Observer Pattern)
核心：定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖者都会收到通知。
[场景]
Excel 表格数据变化时，图表自动更新。
[C++ 示例]
// 1. 抽象观察者
class IObserver {
public:
virtual void OnUpdate(float price) = 0;
};
// 2. 具体被观察者 (Subject)
class BitcoinTicker {
std::vector<IObserver*> observers_;
float price_;
public:
void Attach(IObserver* obs) { observers_.push_back(obs); }
void Notify() {
for (auto* obs : observers_) obs->OnUpdate(price_);
}
};
[SOLID 分析]
- DIP: Subject 只依赖
IObserver接口，解耦了具体的观察者。 - SRP: Subject 只管通知，Observer 只管响应。
2. 委托模式 (Delegation Pattern)
核心：组合优于继承，“我不干活，我找别人干”。
[场景]
代码复用最基础的模式。
[C++ 示例]
class Printer {
public:
void Print(const std::string& msg) { std::cout << msg; }
};
class Logger {
Printer printer_; // Has-a
public:
void Log(const std::string& msg) {
printer_.Print(msg); // 委托
}
};
3. 单例模式 (Singleton Pattern)
核心：保证一个类只有一个实例。
[场景]
全局配置、日志管理器。
[C++ 示例]
class GlobalConfig {
GlobalConfig() {}
public:
static GlobalConfig& Instance() {
static GlobalConfig instance; // 线程安全 (C++11)
return instance;
}
// 禁用拷贝
GlobalConfig(const GlobalConfig&) = delete;
void operator=(const GlobalConfig&) = delete;
};
[SOLID 分析 (反例警示)]
- SRP (反例): 既负责业务又负责生命周期管理。
- DIP (反例): 使用者强依赖具体类，难以 Mock 测试。
注：后续了解一下，在多线程环境下，如何安全的创建单例
4. 命令模式 (Command Pattern)
核心：将请求封装成对象。
[场景]
撤销/重做、任务队列。
[C++ 示例]
// 抽象命令
class ICommand {
public:
virtual void Execute() = 0;
};
// 具体命令
class TurnOnCommand : public ICommand {
Light& light_;
public:
TurnOnCommand(Light& l) : light_(l) {}
void Execute() override { light_.TurnOn(); }
};
// 调用者
class Remote {
std::vector<std::unique_ptr<ICommand>> history_;
public:
void Press(std::unique_ptr<ICommand> cmd) {
cmd->Execute();
history_.push_back(std::move(cmd));
}
};
[SOLID 分析]
- SRP: 解耦了请求发起者和执行者。
- OCP: 增加新命令无需修改调用者逻辑。
5. 工厂模式 (Factory Pattern)
核心：封装对象的创建过程。
[场景]
解耦对象的创建与使用。
[C++ 示例]
class IFactory {
public:
virtual std::unique_ptr<IProduct> Create() = 0;
};
class FactoryA : public IFactory {
public:
std::unique_ptr<IProduct> Create() override {
return std::make_unique<ProductA>();
}
};
[SOLID 分析]
- DIP: 客户端依赖工厂接口，不知道具体产品类名。
- OCP: 增加新产品只需增加新工厂，无需修改现有代码。
6. 代理模式 (Proxy Pattern)
核心：控制对对象的访问。
[场景]
延迟加载（图片）、权限控制。
[C++ 示例]
class ProxyImage : public IImage {
std::unique_ptr<RealImage> real_;
std::string path_;
public:
void Display() override {
if (!real_) real_ = std::make_unique<RealImage>(path_); // 延迟加载
real_->Display();
}
};
[SOLID 分析]
- SRP: 代理只管控制逻辑，真实类只管业务逻辑。
- LSP: 代理和真实类实现同一接口，客户端无感知。
7. 外观模式 (Facade Pattern)
核心：提供统一的高层接口，隐藏子系统的复杂性。
[场景]
一键启动计算机（涉及 CPU、内存、硬盘初始化）。
[C++ 示例]
class ComputerFacade {
CPU cpu_;
Memory mem_;
public:
void Start() {
cpu_.Freeze();
mem_.Load();
// 封装复杂流程
}
};
[SOLID 分析]
- ISP: 为客户端提供了一个专门的、简单的接口。
- DIP: 客户端解耦了底层子系统。
总结
设计模式的本质是 解耦。
- 委托: 算法解耦
- 观察者: 状态解耦
- 命令: 请求解耦
- 工厂: 创建解耦
- 代理: 访问解耦
- 外观: 复杂性解耦
SOLID 原则是指导这些解耦操作的理论基石。
