1. 观察者模式 (Observer Pattern)

核心：定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖者都会收到通知。

[场景]

Excel 表格数据变化时，图表自动更新。

[C++ 示例]

// 1. 抽象观察者
class IObserver {
public:
    virtual void OnUpdate(float price) = 0;
};

// 2. 具体被观察者 (Subject)
class BitcoinTicker {
    std::vector 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> history_;
public:
    void Press(std::unique_ptr cmd) {
        cmd->Execute();
        history_.push_back(std::move(cmd));
    }
};

[SOLID 分析]

• SRP: 解耦了请求发起者和执行者。
• OCP: 增加新命令无需修改调用者逻辑。

5. 工厂模式 (Factory Pattern)

核心：封装对象的创建过程。

[场景]

解耦对象的创建与使用。

[C++ 示例]

class IFactory {
public:
    virtual std::unique_ptr Create() = 0;
};

class FactoryA : public IFactory {
public:
    std::unique_ptr Create() override {
        return std::make_unique();
    }
};

[SOLID 分析]

• DIP: 客户端依赖工厂接口，不知道具体产品类名。
• OCP: 增加新产品只需增加新工厂，无需修改现有代码。

6. 代理模式 (Proxy Pattern)

核心：控制对对象的访问。

[场景]

延迟加载（图片）、权限控制。

[C++ 示例]

class ProxyImage : public IImage {
    std::unique_ptr real_;
    std::string path_;
public:
    void Display() override {
        if (!real_) real_ = std::make_unique(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 原则是指导这些解耦操作的理论基石。