// TemplateMethod.h
#ifndef TEMPLATE_METHOD_H
#define TEMPLATE_METHOD_H

// 抽象基类，定义模板方法
class AbstractClass {
public:
    virtual ~AbstractClass() = default;
    
    // 模板方法，定义算法骨架
    void templateMethod() {
        stepOne();
        stepTwo();
        stepThree();
        if (hookMethod()) {
            stepFour();
        }
    }
    
protected:
    // 基本方法 - 具体实现
    void stepOne() {
        std::cout << "AbstractClass: 执行步骤一" << std::endl;
    }
    
    // 基本方法 - 抽象方法，子类必须实现
    virtual void stepTwo() = 0;
    
    // 基本方法 - 具体实现
    void stepThree() {
        std::cout << "AbstractClass: 执行步骤三" << std::endl;
    }
    
    // 钩子方法 - 可以被子类重写，默认实现
    virtual bool hookMethod() {
        return true;
    }
    
    // 基本方法 - 抽象方法
    virtual void stepFour() = 0;
};

// 具体子类A
class ConcreteClassA : public AbstractClass {
protected:
    void stepTwo() override {
        std::cout << "ConcreteClassA: 执行步骤二" << std::endl;
    }
    
    void stepFour() override {
        std::cout << "ConcreteClassA: 执行步骤四" << std::endl;
    }
};

// 具体子类B
class ConcreteClassB : public AbstractClass {
protected:
    void stepTwo() override {
        std::cout << "ConcreteClassB: 执行步骤二" << std::endl;
    }
    
    bool hookMethod() override {
        // 重写钩子方法，改变算法流程
        std::cout << "ConcreteClassB: 重写钩子方法，返回false" << std::endl;
        return false;
    }
    
    void stepFour() override {
        std::cout << "ConcreteClassB: 执行步骤四" << std::endl;
    }
};

#endif // TEMPLATE_METHOD_H

// main.cpp
#include <iostream>
#include "TemplateMethod.h"

int main() {
    std::cout << "=== 使用 ConcreteClassA ===" << std::endl;
    ConcreteClassA classA;
    classA.templateMethod();
    
    std::cout << "\n=== 使用 ConcreteClassB ===" << std::endl;
    ConcreteClassB classB;
    classB.templateMethod();
    
    return 0;
}