一、设计模式分类与核心价值

设计模式是软件工程中经过验证的解决方案模板，用于解决特定场景下的重复性设计问题。C++作为系统级编程语言，其设计模式应用更侧重于内存管理、对象生命周期控制等底层优化。根据功能可分为三大类：

• 创建型模式（5种）：封装对象创建逻辑，解决资源初始化与依赖管理问题
• 结构型模式（7种）：优化对象/类组合方式，提升代码结构灵活性
• 行为型模式（11种）：规范对象间通信机制，增强系统行为可控性

典型应用场景包括：多线程环境下的资源竞争、复杂业务逻辑的模块化拆分、历史状态回溯需求等。以某大型分布式系统为例，通过合理应用单例模式管理全局配置，使配置更新效率提升40%。

二、创建型模式深度解析

1. 单例模式：全局唯一对象管理

核心问题：确保一个类只有一个实例，并提供全局访问点。

实现方案对比：

// 饿汉式（线程安全但可能浪费资源）
class Singleton {
private:
    static Singleton instance;
    Singleton() {}
public:
    static Singleton& getInstance() { return instance; }
};
// 懒汉式（需加锁保证线程安全）
class LazySingleton {
private:
    static LazySingleton* instance;
    static std::mutex mtx;
    LazySingleton() {}
public:
    static LazySingleton* getInstance() {
        std::lock_guard<std::mutex> lock(mtx);
        if (!instance) instance = new LazySingleton();
        return instance;
    }
};

最佳实践：C++11后推荐使用magic static实现线程安全的懒汉式：

class ThreadSafeSingleton {
public:
    static ThreadSafeSingleton& getInstance() {
        static ThreadSafeSingleton instance;
        return instance;
    }
private:
    ThreadSafeSingleton() {}
};

2. 工厂模式：对象创建的抽象化

适用场景：需要创建多个相关类（共享同一基类）的实例，且具体类型由运行时参数决定。

实现要点：

// 抽象产品接口
class Product {
public:
    virtual ~Product() = default;
    virtual void operation() = 0;
};
// 具体产品
class ConcreteProductA : public Product {
public:
    void operation() override { /* 实现A */ }
};
// 工厂类
class Factory {
public:
    static std::unique_ptr<Product> createProduct(const std::string& type) {
        if (type == "A") return std::make_unique<ConcreteProductA>();
        // 其他类型判断...
        return nullptr;
    }
};

优势：将对象创建代码集中管理，便于维护；通过配置文件即可扩展新产品类型。

3. 建造者模式：复杂对象构造

典型案例：需要分步骤构建包含多个可选参数的对象（如游戏角色配置）。

实现结构：

// 产品类
class Character {
    std::string name;
    int level;
    std::vector<std::string> skills;
public:
    void setName(const std::string& n) { name = n; }
    // 其他setter...
};
// 建造者接口
class CharacterBuilder {
protected:
    Character character;
public:
    virtual ~CharacterBuilder() = default;
    virtual CharacterBuilder& setName(const std::string&) = 0;
    // 其他抽象方法...
    Character build() { return character; }
};
// 具体建造者
class GameCharacterBuilder : public CharacterBuilder {
public:
    GameCharacterBuilder& setName(const std::string& name) override {
        character.setName(name);
        return *this;
    }
    // 实现其他方法...
};

使用示例：

auto builder = GameCharacterBuilder()
    .setName("Warrior")
    .setLevel(10);
Character hero = builder.build();

三、行为型模式精选实践

1. 命令模式：请求封装与解耦

核心价值：将操作请求转化为对象，支持请求排队、撤销等高级功能。

典型实现：

// 命令接口
class Command {
public:
    virtual ~Command() = default;
    virtual void execute() = 0;
    virtual void undo() = 0;
};
// 具体命令
class LightOnCommand : public Command {
    Light* light;
public:
    LightOnCommand(Light* l) : light(l) {}
    void execute() override { light->turnOn(); }
    void undo() override { light->turnOff(); }
};
// 调用者
class RemoteControl {
    Command* command;
public:
    void setCommand(Command* cmd) { command = cmd; }
    void pressButton() { command->execute(); }
};

扩展应用：结合std::function实现更灵活的命令封装：

using CommandFunc = std::function<void()>;
class FunctionalCommand {
    CommandFunc executeFunc;
    CommandFunc undoFunc;
public:
    FunctionalCommand(CommandFunc exec, CommandFunc und) 
        : executeFunc(exec), undoFunc(und) {}
    void execute() { executeFunc(); }
    void undo() { undoFunc(); }
};

2. 观察者模式：事件驱动架构

实现方案对比：

• 手动实现：维护观察者列表，事件触发时遍历通知

  class Subject {
    std::vector<std::function<void()>> observers;
  public:
    void attach(std::function<void()> observer) {
        observers.push_back(observer);
    }
    void notify() {
        for (auto& obs : observers) obs();
    }
  };

• 标准库方案：使用<functional>与<vector>组合
• 第三方库：如Boost.Signals2提供更完善的事件处理机制

性能优化：对于高频事件，建议使用无锁队列实现观察者通知，避免锁竞争。

3. 状态模式：对象行为动态切换

典型场景：订单状态机（待支付→已支付→已发货→已完成）。

实现结构：

// 状态接口
class OrderState {
public:
    virtual ~OrderState() = default;
    virtual void pay(OrderContext&) = 0;
    virtual void deliver(OrderContext&) = 0;
};
// 具体状态
class PaidState : public OrderState {
public:
    void pay(OrderContext&) override { /* 已支付状态不允许重复支付 */ }
    void deliver(OrderContext& ctx) override {
        ctx.setState(std::make_unique<DeliveredState>());
        // 执行发货逻辑...
    }
};
// 上下文类
class OrderContext {
    std::unique_ptr<OrderState> state;
public:
    void setState(std::unique_ptr<OrderState> s) { state = std::move(s); }
    void pay() { state->pay(*this); }
    // 其他方法...
};

优势：避免大量条件判断语句，符合开闭原则。

四、设计模式选型指南

1. 创建需求：

   • 需要严格控制实例数量 → 单例模式
   • 对象构造过程复杂 → 建造者模式
   • 创建逻辑需要动态决定 → 工厂模式

2. 行为需求：

   • 需要撤销/重做功能 → 命令模式
   • 对象状态决定行为 → 状态模式
   • 实现松耦合通信 → 观察者/中介者模式

3. 结构需求：

   • 组合对象需要统一接口 → 适配器模式
   • 动态添加功能 → 装饰器模式
   • 共享可复用对象 → 享元模式

避坑指南：

• 避免过度设计：简单场景直接编码比使用模式更高效
• 注意模式副作用：如单例模式可能引发线程安全问题
• 考虑测试难度：某些模式（如状态模式）会增加单元测试复杂度

五、现代C++对设计模式的演进

1. 智能指针：简化资源管理，减少单例模式中的内存泄漏风险
2. Lambda表达式：替代简单命令对象，使代码更简洁
3. 概念(Concept)：为行为模式提供更严格的类型约束
4. 协程：改变异步编程模式，可能影响观察者模式实现方式

典型案例：使用C++20协程重构观察者模式：

generator<void> eventProcessor() {
    while (true) {
        auto event = co_await eventQueue.pop();
        co_yield processEvent(event); // 通知观察者
    }
}

结语

设计模式是编程思想的结晶，但并非银弹。在实际开发中，应结合具体业务场景、团队技术栈和性能要求进行选择。建议从重构现有代码开始实践，逐步掌握模式的应用时机与变体实现。对于复杂系统，可考虑将多个模式组合使用（如工厂模式+建造者模式构建复杂对象），但需注意保持代码可读性。