C++模板方法模式

文章目录

- - 1. 定义抽象基类（Abstract Class）
  - 2. 实现具体子类（Concrete Class）
  - 3. 使用模板方法
  - 模板方法模式的优点
  - 模板方法模式的应用场景
  - 注意事项
  - 实现示例
  - - 抽象类（模板）
    - 具体实现类
    - 客户端代码
  - 总结

模板方法模式是一种行为设计模式，它定义了一个操作中的算法骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变算法的结构即可重定义该算法的某些特定步骤。这种模式非常适合需要控制算法流程，同时允许子类自定义部分行为的场景。

在C++中实现模板方法模式的基本步骤如下：

1. 定义抽象基类（Abstract Class）

首先，定义一个抽象基类，这个基类中包含了一个或多个模板方法和一些抽象方法或具体方法。模板方法定义了算法的整体框架，而抽象方法则是留给子类实现的。

class AbstractClass {
public:
    // 模板方法，定义了算法的骨架
    void templateMethod() {
        primitiveOperation1();
        primitiveOperation2();
    }

    // 抽象方法，由子类实现
    virtual void primitiveOperation1() = 0;
    
    // 可能还有其他抽象或具体方法
    virtual void primitiveOperation2() {
        // 默认实现
    }
protected:
    // 可能包含受保护的辅助方法
};

2. 实现具体子类（Concrete Class）

然后，创建抽象基类的子类，并实现其中的抽象方法。子类可以根据需要重写具体方法，但模板方法的结构保持不变。

class ConcreteClassA : public AbstractClass {
public:
    void primitiveOperation1() override {
        // 实现具体操作1
    }
    
    // 如果需要，也可以重写primitiveOperation2
};

class ConcreteClassB : public AbstractClass {
public:
    void primitiveOperation1() override {
        // 实现与ConcreteClassA不同的操作1
    }
};

3. 使用模板方法

客户端代码仅需调用模板方法，而无需知道算法的具体实现细节，提高了代码的抽象层次和复用性。

int main() {
    AbstractClass* a = new ConcreteClassA();
    a->templateMethod();
    delete a;

    AbstractClass* b = new ConcreteClassB();
    b->templateMethod();
    delete b;

    return 0;
}

在这个例子中，templateMethod是模板方法，它定义了执行操作的顺序，而primitiveOperation1和primitiveOperation2是抽象方法，由子类实现具体的业务逻辑。这样，我们可以在不修改模板方法的情况下，通过更换不同的子类来改变算法的部分步骤，实现了算法的结构稳定性和步骤可变性的良好平衡。

模板方法模式的优点

代码复用：模板方法模式在一个类中定义了算法的骨架，而将一些步骤延迟到子类中实现，这使得相同的基本算法可以有不同的具体实现，提高了代码的复用性。
封装不变部分：将算法中的不变部分（算法的框架）封装在基类的模板方法中，确保了算法整体结构的稳定性和一致性。
扩展性好：新增新的具体实现时，只需要添加新的子类并实现相应的抽象方法，而不需要修改现有的类库代码，符合开闭原则。
行为控制：父类可以通过控制模板方法中的逻辑顺序，来控制子类的行为，增强了对系统行为的集中控制。

模板方法模式的应用场景

框架开发：许多软件框架会使用模板方法模式定义其核心流程，而将具体实现留给用户自定义。比如，Junit测试框架中的测试用例运行流程就是一个模板方法模式的例子。
UI框架：在图形用户界面（GUI）框架中，绘制组件或处理事件的流程往往是一个固定的模板，而具体的绘制内容或事件响应则由各个组件自己实现。
数据库访问库：数据库操作通常包括打开连接、执行查询、处理结果集、关闭连接等固定步骤，这些步骤可以作为模板方法定义，而具体的SQL语句和结果处理由子类实现。

注意事项

避免过度设计：虽然模板方法模式可以增加代码的灵活性和扩展性，但如果滥用可能导致系统结构过于复杂，增加了理解和维护的难度。
性能考量：由于涉及到虚函数调用，模板方法模式在性能敏感的应用中可能需要权衡。虽然现代编译器的优化已经大大减少了这种开销，但在极端性能要求下仍需注意。
设计决策：确定哪些部分作为模板方法，哪些部分留给子类实现，需要仔细考虑，以达到既灵活又不失控制的目的。

总之，模板方法模式是面向对象设计中一种非常实用的模式，适用于需要定义算法框架并允许子类对部分步骤进行定制化的场景。正确使用它可以显著提升代码的结构和可维护性。

实现示例

为了更好地理解模板方法模式，下面通过一个简单的例子来说明其应用：假设我们正在设计一个冲泡饮料的框架，无论是咖啡还是茶，冲泡过程都包含几个通用步骤（烧水、加入原料、搅拌、倒入杯中），但具体每个步骤的实现细节（如原料种类）根据不同饮料而异。

抽象类（模板）

首先，我们定义一个抽象类Beverage，它充当模板方法模式中的抽象模板角色，定义了冲泡饮料的整个流程框架。

public abstract class Beverage {
    // 模板方法，定义冲泡流程
    public final void brew() {
        boilWater();
        brew();
        pourInCup();
        if (customerWantsCondiments()) {
            addCondiments();
        }
    }

    // 基本方法，由子类实现
    protected abstract void brew(); // 冲泡（咖啡或茶）
    protected abstract void addCondiments(); // 添加调料（奶、糖等）

    // 具体方法，已实现
    private void boilWater() {
        System.out.println("Boiling water");
    }

    private void pourInCup() {
        System.out.println("Pouring into cup");
    }

    // 钩子方法，可被子类重写以改变默认行为
    protected boolean customerWantsCondiments() {
        return true;
    }
}

具体实现类

然后，我们创建两个具体实现类，分别代表咖啡(Coffee)和茶(Tea)，它们继承自Beverage类，并实现其中的抽象方法。

public class Coffee extends Beverage {
    @Override
    protected void brew() {
        System.out.println("Brewing Coffee");
    }

    @Override
    protected void addCondiments() {
        System.out.println("Adding Sugar and Milk to Coffee");
    }
}

public class Tea extends Beverage {
    @Override
    protected void brew() {
        System.out.println("Steeping the Tea");
    }

    @Override
    protected void addCondiments() {
        System.out.println("Adding Lemon");
    }
}

客户端代码

最后，客户端代码仅需实例化具体饮料类并调用brew()方法，无需关注冲泡的具体步骤。

public class StarbuzzCoffee {
    public static void main(String[] args) {
        Beverage beverage = new Coffee();
        beverage.brew();

        System.out.println("\n");

        beverage = new Tea();
        beverage.brew();
    }
}