// TemplateMethod.h

#ifndef _TEMPLATEMETHOD_H_
#define _TEMPLATEMETHOD_H_

//抽象模板，并定义了一个模板方法。
class AbstractClass
{
public:
    ~AbstractClass();
    //具体的模板方法，给出了逻辑的骨架，而逻辑的组成是一些相应的抽象操作，它们都推迟到子类中实现
    void TemplateMethod();

protected:
    AbstractClass();

    //一些抽象行为，放到子类中去实现
    virtual void PrimitiveOperation1()=0;
    virtual void PrimitiveOperation2()=0;
};

//实现基类所定义的抽象方法
class ConcreteClassA : public AbstractClass
{
public:
    ConcreteClassA();
    ~ConcreteClassA();

protected:
    //实现基类定义的抽象行为
    virtual void PrimitiveOperation1();
    virtual void PrimitiveOperation2();
};

//实现基类所定义的抽象方法
class ConcreteClassB : public AbstractClass
{
public:
    ConcreteClassB();
    ~ConcreteClassB();

protected:
    //实现基类定义的抽象行为
    virtual void PrimitiveOperation1();
    virtual void PrimitiveOperation2();
};

#endif

//TemplateMethod.cpp

#include "TemplateMethod.h"
#include <iostream>

using namespace std;

AbstractClass::AbstractClass(){}

AbstractClass::~AbstractClass(){}

void AbstractClass::TemplateMethod()
{
    this->PrimitiveOperation1();
    this->PrimitiveOperation2();
}

ConcreteClassA::ConcreteClassA(){}

ConcreteClassA::~ConcreteClassA(){}

void ConcreteClassA::PrimitiveOperation1()
{
    cout << "ConcreteClassA::PrimitiveOperation1" << endl;
}

void ConcreteClassA::PrimitiveOperation2()
{
    cout << "ConcreteClassA::PrimitiveOperation2" << endl;
}

ConcreteClassB::ConcreteClassB(){}

ConcreteClassB::~ConcreteClassB(){}

void ConcreteClassB::PrimitiveOperation1()
{
    cout << "ConcreteClassB::PrimitiveOperation1" << endl;
}

void ConcreteClassB::PrimitiveOperation2()
{
    cout << "ConcreteClassB::PrimitiveOperation2" << endl;
}

// main.cpp

#include "TemplateMethod.h"

int main()
{
    //ConcreteClassA与ConcreteClassB可相互替换
    AbstractClass* pAbstract = new ConcreteClassA();
    pAbstract->TemplateMethod();

    pAbstract = new ConcreteClassB();
    pAbstract->TemplateMethod();
    
    return 0;
}