第30章 设计模式基础

调试日志里频繁出现“内存泄漏”，新加一个功能要修改十几个文件，团队成员抱怨代码像“意大利面条”一样难以理解——如果你遇到过这些问题，说明你的项目架构需要设计模式了。设计模式不是语法，而是针对特定设计问题的、可复用的优秀解决方案模板。

设计模式的“家族”与核心价值

GoF（四人帮）的经典著作《设计模式：可复用面向对象软件的基础》归纳了23种模式，分为三大类。理解这个分类，能帮你快速定位问题该用哪个模式解决。

实际开发中，大部分团队会优先掌握其中5-8个最常用的模式。设计模式的核心价值在于：提升代码复用性、增强系统可扩展性、降低模块间耦合度、提高代码可读性。 我在一个图像处理项目中，通过引入工厂模式，将支持新图片格式的开发时间从2天缩短到2小时。

创建型模式：解开对象创建的枷锁

当你的代码中充斥着大量的 new 关键字，并且创建逻辑复杂多变时，创建型模式就该登场了。它封装了对象的创建过程，使系统独立于具体对象的创建、组合和表示。

单例模式：全局唯一的“管家”

日志系统是单例模式的经典场景。如果每个模块都自己创建日志对象，不仅浪费资源，还可能导致日志文件写入冲突。

// C++11 线程安全的Meyer‘s Singleton实现（推荐）
class Logger {
public:
    static Logger& getInstance() {
        static Logger instance; // C++11保证局部静态变量初始化线程安全
        return instance;
    }
    void log(const std::string& message) {
        // 写入日志文件...
        std::cout << "[LOG] " << message << std::endl;
    }
    // 禁止拷贝和赋值
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;
private:
    Logger() {} // 私有构造函数
    ~Logger() {}
};

// 使用方式
Logger::getInstance().log("Application started.");

工厂方法模式：生产线的标准化

假设你正在开发一个支持多种传感器（如温度传感器DHT22、湿度传感器SHT31）的数据采集框架。每次新增传感器类型，都要修改核心采集逻辑，这违反了“开闭原则”。

// 产品接口
class Sensor {
public:
    virtual ~Sensor() = default;
    virtual float readData() = 0;
};

// 具体产品
class DHT22Sensor : public Sensor { public: float readData() override { /* 读取温度 */ return 25.3; } };
class SHT31Sensor : public Sensor { public: float readData() override { /* 读取湿度 */ return 60.5; } };

// 简单工厂（非严格GoF工厂方法，但更常用）
class SensorFactory {
public:
    static std::unique_ptr createSensor(const std::string& type) {
        if (type == "DHT22") return std::make_unique();
        else if (type == "SHT31") return std::make_unique();
        // 新增传感器只需修改这里
        return nullptr;
    }
};

如果你看到代码里有一长串的 if-else 或 switch-case 来创建对象，这就是引入工厂模式的强烈信号。我在一个通信协议解析项目中踩过这个坑，最初用条件判断创建不同协议解析器，后来协议增加到十几种，代码变得难以维护，改用工厂模式配合注册表后清爽多了。

结构型模式：搭建灵活的类关系

结构型模式关注如何将类或对象组合成更大、更复杂的结构，同时保持结构的灵活和高效。这里我们重点看一个极其常用的模式——适配器模式。

假设你项目里有一个遗留的、接口陈旧的第三方日志库 OldLogger，它只有一个 writeToConsole 方法。但你的新系统统一使用一个接收 std::string 参数的 log 接口。

// 已有的、不兼容的类
class OldLogger {
public:
    void writeToConsole(const char* msg, int length) {
        std::cout.write(msg, length);
    }
};

// 目标接口（你的新系统标准）
class NewLoggerInterface {
public:
    virtual ~NewLoggerInterface() = default;
    virtual void log(const std::string& message) = 0;
};

// 适配器类：继承目标接口，内部包含一个OldLogger对象
class LoggerAdapter : public NewLoggerInterface {
private:
    OldLogger oldLogger;
public:
    void log(const std::string& message) override {
        // 适配过程：将string接口转换为char*和length
        oldLogger.writeToConsole(message.c_str(), message.size());
    }
};

// 客户端代码可以统一使用NewLoggerInterface接口，无需知道OldLogger的存在
std::unique_ptr logger = std::make_unique();
logger->log("Hello, Adapter Pattern!");

行为型模式：对象间的智慧协作

行为型模式负责对象间的高效通信和职责分配。观察者模式是其中使用频率最高的模式之一，它定义了对象间的一种一对多的依赖关系，当一个对象状态改变时，所有依赖它的对象都会得到通知并自动更新。

下面是一个简化的C++实现框架，注意使用弱引用来避免观察者对象生命周期管理带来的问题。

#include 
#include 
#include 

// 前向声明
class Observer;

// 被观察者（主题）
class Subject {
    std::vector> observers_; // 使用weak_ptr避免循环引用
    std::string state_;
public:
    void attach(std::weak_ptr obs) { observers_.push_back(obs); }
    void setState(const std::string& newState) {
        state_ = newState;
        notify();
    }
    void notify(); // 通知所有观察者
    std::string getState() const { return state_; }
};

// 观察者接口
class Observer : public std::enable_shared_from_this {
public:
    virtual ~Observer() = default;
    virtual void update(Subject* subject) = 0;
};

void Subject::notify() {
    for (auto& weakObs : observers_) {
        if (auto obs = weakObs.lock()) { // 检查观察者是否还存在
            obs->update(this);
        }
    }
}

// 具体观察者
class ConcreteObserver : public Observer {
    std::string name_;
public:
    ConcreteObserver(const std::string& name) : name_(name) {}
    void update(Subject* subject) override {
        std::cout << name_ << " received update. New state: " << subject->getState() << std::endl;
    }
};