C++的23种设计模式

设计模式是软件设计中的最佳实践，提供了解决常见问题的标准方法。以下是 C++ 中的 23 种经典设计模式，分为三类：创建型、结构型和行为型。

1. 创建型模式

1.1 单例模式（Singleton）

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

cpp

cpp 复制代码

class Singleton {
public:
    // 静态方法获取唯一实例
    static Singleton& getInstance() {
        static Singleton instance; // 在第一次调用时创建实例
        return instance; // 返回实例引用
    }
    
private:
    Singleton() {} // 私有构造函数，防止外部实例化
    Singleton(const Singleton&) = delete; // 禁止复制构造
    void operator=(const Singleton&) = delete; // 禁止赋值操作
};

1.2 工厂方法模式（Factory Method）

定义一个创建对象的接口，让子类决定实例化哪一个类。

cpp

cpp 复制代码

// 产品接口
class Product {
public:
    virtual void use() = 0; // 纯虚函数，子类必须实现
};

// 具体产品实现
class ConcreteProduct : public Product {
public:
    void use() override { /* 实现具体功能 */ }
};

// 创建者接口
class Creator {
public:
    virtual Product* factoryMethod() = 0; // 创建产品的接口
};

// 具体创建者实现
class ConcreteCreator : public Creator {
public:
    Product* factoryMethod() override {
        return new ConcreteProduct(); // 返回具体产品实例
    }
};

1.3 抽象工厂模式（Abstract Factory）

提供一个接口，用于创建一系列相关或相互依赖的对象，而无需指定具体类。

cpp

cpp 复制代码

// 抽象产品 A
class ProductA {
public:
    virtual void operationA() = 0;
};

// 抽象产品 B
class ProductB {
public:
    virtual void operationB() = 0;
};

// 抽象工厂接口
class AbstractFactory {
public:
    virtual ProductA* createProductA() = 0; // 创建产品 A
    virtual ProductB* createProductB() = 0; // 创建产品 B
};

// 具体工厂实现
class ConcreteFactory : public AbstractFactory {
public:
    ProductA* createProductA() override {
        return new ConcreteProductA(); // 返回具体产品 A
    }
    ProductB* createProductB() override {
        return new ConcreteProductB(); // 返回具体产品 B
    }
};

1.4 建造者模式（Builder）

使用多个简单的对象一步步构建一个复杂的对象。

cpp

cpp 复制代码

// 产品类
class Product {
public:
    void addPart(const std::string& part) {
        // 添加部件到产品
    }
};

// 抽象建造者
class Builder {
public:
    virtual void buildPart() = 0; // 建造部件
    Product* getResult() {
        return product; // 返回构建好的产品
    }
protected:
    Product* product; // 需要构建的产品
};

// 具体建造者实现
class ConcreteBuilder : public Builder {
public:
    void buildPart() override {
        product->addPart("Part1"); // 构建特定部件
    }
};

1.5 原型模式（Prototype）

通过复制已有的实例来创建新对象，而不是通过类构造。

cpp

cpp 复制代码

// 原型接口
class Prototype {
public:
    virtual Prototype* clone() const = 0; // 克隆方法
};

// 具体原型实现
class ConcretePrototype : public Prototype {
public:
    Prototype* clone() const override {
        return new ConcretePrototype(*this); // 复制当前实例
    }
};

2. 结构型模式

2.1 适配器模式（Adapter）

将一个类的接口转换成客户希望的另一个接口。

cpp

cpp 复制代码

// 目标接口
class Target {
public:
    virtual void request() = 0; // 客户期望的接口
};

// 被适配的类
class Adaptee {
public:
    void specificRequest() {
        // 特定请求的实现
    }
};

// 适配器实现
class Adapter : public Target {
private:
    Adaptee* adaptee; // 持有被适配对象的指针
public:
    void request() override {
        adaptee->specificRequest(); // 调用被适配的请求
    }
};

2.2 桥接模式（Bridge）

将抽象与实现分离，使它们可以独立变化。

cpp

cpp 复制代码

// 实现者接口
class Implementor {
public:
    virtual void operationImpl() = 0; // 实现方法
};

// 抽象类
class Abstraction {
protected:
    Implementor* implementor; // 持有实现者的指针
public:
    virtual void operation() {
        implementor->operationImpl(); // 调用实现者的方法
    }
};

2.3 组合模式（Composite）

将对象组合成树形结构以表示部分-整体层次结构。

cpp

cpp 复制代码

// 组件接口
class Component {
public:
    virtual void operation() = 0; // 组件方法
};

// 叶子节点
class Leaf : public Component {
public:
    void operation() override {
        // 叶子节点的具体操作
    }
};

// 组合节点
class Composite : public Component {
private:
    std::vector<Component*> children; // 存储子组件
public:
    void operation() override {
        for (auto child : children) {
            child->operation(); // 执行所有子组件的操作
        }
    }
};

2.4 装饰者模式（Decorator）

动态地给一个对象添加一些额外的职责。

cpp

cpp 复制代码

// 组件接口
class Component {
public:
    virtual void operation() = 0; // 组件方法
};

// 具体组件
class ConcreteComponent : public Component {
public:
    void operation() override {
        // 具体组件的操作
    }
};

// 装饰者基类
class Decorator : public Component {
protected:
    Component* component; // 持有被装饰的组件
public:
    Decorator(Component* comp) : component(comp) {}
    void operation() override {
        component->operation(); // 调用被装饰组件的操作
    }
};

// 具体装饰者
class ConcreteDecorator : public Decorator {
public:
    ConcreteDecorator(Component* comp) : Decorator(comp) {}
    void operation() override {
        Decorator::operation(); // 调用父类操作
        // 添加装饰功能
    }
};

2.5 外观模式（Facade）

为子系统中的一组接口提供一个统一的高层接口。

cpp

cpp 复制代码

// 子系统类
class SubsystemA {
public:
    void operationA() { /* ... */ }
};

class SubsystemB {
public:
    void operationB() { /* ... */ }
};

// 外观类
class Facade {
private:
    SubsystemA* subsystemA;
    SubsystemB* subsystemB;
public:
    Facade() {
        subsystemA = new SubsystemA();
        subsystemB = new SubsystemB();
    }
    void operation() {
        subsystemA->operationA(); // 简化调用
        subsystemB->operationB(); // 简化调用
    }
};

2.6 享元模式（Flyweight）

通过共享对象来有效地支持大量细粒度的对象。

cpp

cpp 复制代码

// 享元接口
class Flyweight {
public:
    virtual void operation() = 0; // 享元方法
};

// 具体享元
class ConcreteFlyweight : public Flyweight {
public:
    void operation() override {
        // 具体享元的操作
    }
};

// 享元工厂
class FlyweightFactory {
public:
    Flyweight* getFlyweight(const std::string& key) {
        // 根据键获取享元对象
    }
};

2.7 代理模式（Proxy）

为其他对象提供一种代理以控制对这个对象的访问。

cpp

cpp 复制代码

// 主题接口
class Subject {
public:
    virtual void request() = 0; // 请求方法
};

// 真实主题
class RealSubject : public Subject {
public:
    void request() override {
        // 实际请求处理
    }
};

// 代理
class Proxy : public Subject {
private:
    RealSubject* realSubject; // 持有真实主题的指针
public:
    void request() override {
        // 代理的处理
        if (!realSubject) {
            realSubject = new RealSubject(); // 懒加载
        }
        realSubject->request(); // 转发请求
    }
};

3. 行为型模式

3.1 责任链模式（Chain of Responsibility）

将请求的发送者和接收者解耦，通过一系列处理者来处理请求。

cpp

cpp 复制代码

// 处理者接口
class Handler {
protected:
    Handler* next; // 下一个处理者
public:
    virtual void handleRequest(int request) {
        if (next) {
            next->handleRequest(request); // 转发请求
        }
    }
};

// 具体处理者
class ConcreteHandlerA : public Handler {
public:
    void handleRequest(int request) override {
        if (request < 10) {
            // 处理请求
        } else {
            Handler::handleRequest(request); // 转发到下一个处理者
        }
    }
};

3.2 命令模式（Command）

将请求封装为对象，从而可以用不同的请求对客户进行参数化。

cpp

cpp 复制代码

// 命令接口
class Command {
public:
    virtual void execute() = 0; // 执行命令
};

// 具体命令
class ConcreteCommand : public Command {
private:
    Receiver* receiver; // 持有接收者
public:
    void execute() override {
        receiver->action(); // 调用接收者的方法
    }
};

// 调用者
class Invoker {
private:
    Command* command; // 持有命令对象
public:
    void setCommand(Command* cmd) {
        command = cmd; // 设置命令
    }
    void invoke() {
        command->execute(); // 执行命令
    }
};

3.3 解释器模式（Interpreter）

给定一个语言，定义它的文法，并定义一个解释器来处理该语言。

cpp

cpp 复制代码

// 抽象表达式
class Expression {
public:
    virtual int interpret() = 0; // 解释方法
};

// 终结符表达式
class TerminalExpression : public Expression {
public:
    int interpret() override {
        return 1; // 返回常量值
    }
};

// 非终结符表达式
class NonTerminalExpression : public Expression {
private:
    Expression* left;
    Expression* right;
public:
    int interpret() override {
        return left->interpret() + right->interpret(); // 组合解释结果
    }
};

3.4 迭代器模式（Iterator）

提供一种方法顺序访问一个集合对象中的元素，而不暴露其内部表示。

cpp

cpp 复制代码

// 迭代器接口
class Iterator {
public:
    virtual void first() = 0; // 移动到第一个元素
    virtual void next() = 0; // 移动到下一个元素
    virtual bool isDone() = 0; // 检查是否结束
    virtual Item currentItem() = 0; // 获取当前元素
};

// 具体集合类
class ConcreteCollection {
private:
    std::vector<Item> items; // 存储元素
public:
    Iterator* createIterator() {
        return new ConcreteIterator(this); // 创建迭代器
    }
};

// 具体迭代器实现
class ConcreteIterator : public Iterator {
private:
    ConcreteCollection* collection; // 持有集合
    int current; // 当前索引
public:
    void first() override { current = 0; } // 重置为第一个元素
    void next() override { current++; } // 移动到下一个元素
    bool isDone() override { return current >= collection->size(); } // 检查结束
    Item currentItem() override { return collection->get(current); } // 获取当前元素
};

3.5 中介者模式（Mediator）

通过一个中介对象来封装一系列的对象交互。

cpp

cpp 复制代码

// 中介者接口
class Mediator {
public:
    virtual void notify(Component* sender, const std::string& event) = 0; // 通知方法
};

// 具体中介者实现
class ConcreteMediator : public Mediator {
private:
    ComponentA* componentA; // 组件 A
    ComponentB* componentB; // 组件 B
public:
    void notify(Component* sender, const std::string& event) override {
        // 根据事件处理交互
    }
};

// 组件接口
class Component {
protected:
    Mediator* mediator; // 持有中介者的指针
public:
    Component(Mediator* med) : mediator(med) {}
    virtual void operation() = 0; // 组件操作
};

3.6 备忘录模式（Memento）

在不暴露对象实现细节的情况下，捕获一个对象的内部状态，并在以后恢复该状态。

cpp

cpp 复制代码

// 备忘录类
class Memento {
public:
    // 存储状态
};

// 发起者类
class Originator {
private:
    std::string state; // 内部状态
public:
    Memento createMemento() {
        return Memento(state); // 创建备忘录
    }
    void restoreFromMemento(const Memento& memento) {
        state = memento.getState(); // 恢复状态
    }
};

3.7 状态模式（State）

允许一个对象在其内部状态改变时改变它的行为。

cpp

cpp 复制代码

// 状态接口
class State {
public:
    virtual void handle(Context* context) = 0; // 处理方法
};

// 具体状态实现
class ConcreteStateA : public State {
public:
    void handle(Context* context) override {
        // 状态 A 的处理逻辑
    }
};

// 上下文类
class Context {
private:
    State* state; // 当前状态
public:
    void request() {
        state->handle(this); // 处理请求
    }
    void setState(State* newState) {
        state = newState; // 切换状态
    }
};

3.8 策略模式（Strategy）

定义一系列算法，将每一个算法封装起来，并使它们可以互换。

cpp

cpp 复制代码

// 策略接口
class Strategy {
public:
    virtual void algorithm() = 0; // 算法方法
};

// 具体策略实现
class ConcreteStrategyA : public Strategy {
public:
    void algorithm() override {
        // 策略 A 的实现
    }
};

// 上下文类
class Context {
private:
    Strategy* strategy; // 持有策略
public:
    void setStrategy(Strategy* s) {
        strategy = s; // 设置策略
    }
    void execute() {
        strategy->algorithm(); // 执行策略
    }
};

3.9 访问者模式（Visitor）

表示一个作用于某对象结构中的各元素的操作。

cpp

cpp 复制代码

// 访问者接口
class Visitor {
public:
    virtual void visit(Element* element) = 0; // 访问方法
};

// 元素接口
class Element {
public:
    virtual void accept(Visitor* visitor) = 0; // 接受访问者
};

// 具体元素实现
class ConcreteElement : public Element {
public:
    void accept(Visitor* visitor) override {
        visitor->visit(this); // 允许访问者访问
    }
};

3.10 观察者模式（Observer）

定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象的状态变化。

cpp

cpp 复制代码

// 观察者接口
class Observer {
public:
    virtual void update() = 0; // 更新方法
};

// 主题接口
class Subject {
public:
    virtual void attach(Observer* observer) = 0; // 添加观察者
    virtual void detach(Observer* observer) = 0; // 移除观察者
    virtual void notify() = 0; // 通知观察者
};

// 具体主题实现
class ConcreteSubject : public Subject {
private:
    std::vector<Observer*> observers; // 存储观察者
public:
    void attach(Observer* observer) override {
        observers.push_back(observer); // 添加观察者
    }

    void detach(Observer* observer) override {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end()); // 移除观察者
    }

    void notify() override {
        for (Observer* observer : observers) {
            observer->update(); // 通知所有观察者
        }
    }

    void changeState() {
        // 改变状态
        notify(); // 状态变化时通知观察者
    }
};

// 具体观察者实现
class ConcreteObserver : public Observer {
public:
    void update() override {
        // 响应主题的更新
    }
};

3.11 模板方法模式（Template Method）

定义一个操作的算法框架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变算法的结构即可重新定义该算法的某些特定步骤。

cpp

cpp 复制代码

// 抽象类
class AbstractClass {
public:
    // 模板方法
    void templateMethod() {
        step1(); // 执行步骤 1
        step2(); // 执行步骤 2
        step3(); // 执行步骤 3
    }

protected:
    virtual void step1() { /* 默认实现 */ } // 步骤 1
    virtual void step2() = 0; // 步骤 2，必须由子类实现
    virtual void step3() { /* 默认实现 */ } // 步骤 3
};

// 具体类实现
class ConcreteClass : public AbstractClass {
protected:
    void step2() override {
        // 自定义步骤 2 的实现
    }
};

结论

这些设计模式提供了通用的解决方案，可以帮助开发者在软件设计中提高代码的可维护性、可重用性和灵活性。