设计模式-行为型模式-模板方法

源码工程：

c++设计模式-行为型模式-模板方法模式-C++文档类资源-CSDN下载c++设计模式-行为型模式-模板方法模式；qt工程；c++简单源码；模板方法（TemplateM更多下载资源、学习资料请访问CSDN下载频道.https://download.csdn.net/download/qq_40788199/85691059码云：

c++设计模式-行为型模式-模板方法https://gitee.com/gongguixing/c-design-mode.git

1、模式的定义与特点

模板方法（Template Method）模式的定义如下：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。它是一种类行为型模式。

该模式的主要优点如下。

1. 它封装了不变部分，扩展可变部分。它把认为是不变部分的算法封装到父类中实现，而把可变部分算法由子类继承实现，便于子类继续扩展。
2. 它在父类中提取了公共的部分代码，便于代码复用。
3. 部分方法是由子类实现的，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。

该模式的主要缺点如下。

1. 对每个不同的实现都需要定义一个子类，这会导致类的个数增加，系统更加庞大，设计也更加抽象，间接地增加了系统实现的复杂度。
2. 父类中的抽象方法由子类实现，子类执行的结果会影响父类的结果，这导致一种反向的控制结构，它提高了代码阅读的难度。
3. 由于继承关系自身的缺点，如果父类添加新的抽象方法，则所有子类都要改一遍。

2、模式的结构与实现 

模板方法模式包含以下主要角色。

1）抽象类/抽象模板（Abstract Class）

抽象模板类，负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。这些方法的定义如下。

① 模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法。

② 基本方法：是整个算法中的一个步骤，包含以下几种类型。

• 抽象方法：在抽象类中声明，由具体子类实现。
• 具体方法：在抽象类中已经实现，在具体子类中可以继承或重写它。
• 钩子方法：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。

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

具体实现类，实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的一个组成步骤。

3、代码实现：

为更容易理解，所以举具体例子

3.1、抽象类 

#ifndef IDRINKTEMPLATE_H
#define IDRINKTEMPLATE_H

// 抽象类/抽象模板（Abstract Class）
// 负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。
// 模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法。
// 基本方法：是整个算法中的一个步骤，包含以下几种类型。
// 抽象方法：在抽象类中声明，由具体子类实现。
// 具体方法：在抽象类中已经实现，在具体子类中可以继承或重写它。
// 钩子方法：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。

class IDrinkTemplate
{
public:
    IDrinkTemplate();
    virtual ~IDrinkTemplate();

    // 抽象方法，推迟到子类实现
    // 煮开水
    virtual void boilWater()    = 0;
    // 冲泡
    virtual void brew()         = 0;
    // 倒入杯中
    virtual void poulInCup()    = 0;
    // 加料
    virtual void addSomething() = 0;

    // 定义一个操作中的算法骨架,模板方法
    // 制作饮料
    virtual void make();
};

#endif // IDRINKTEMPLATE_H

#include "idrinktemplate.h"

IDrinkTemplate::IDrinkTemplate()
{

}

IDrinkTemplate::~IDrinkTemplate()
{

}

void IDrinkTemplate::make()
{
    boilWater();
    brew();
    poulInCup();
    addSomething();
}

 3.1、具体实现类：咖啡

#ifndef COFFEE_H
#define COFFEE_H

#include "idrinktemplate.h"

// 具体实现类，实现抽象类中所定义的抽象方法和钩子方法，
// 它们是一个顶级逻辑的一个组成步骤。
class Coffee : public IDrinkTemplate
{
public:
    Coffee();

    // 重写父类抽象方法
    // 煮开水
    void boilWater()    override;
    // 冲泡
    void brew()         override;
    // 倒入杯中
    void poulInCup()    override;
    // 加料
    void addSomething() override;

    // 可以重写父类模板方法，加上自己的一些内容
    void make() override;
};

#endif // COFFEE_H

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

Coffee::Coffee()
{

}

void Coffee::boilWater()
{
    std::cout << "Boiled mountain spring water." << std::endl;
}

void Coffee::brew()
{
    std::cout << "Brewing coffee." << std::endl;
}

void Coffee::poulInCup()
{
    std::cout << "Pour into a coffee cup." << std::endl;
}

void Coffee::addSomething()
{
    std::cout << "Add milk to coffee." << std::endl;
}

void Coffee::make()
{
    // 调用父类方法
    IDrinkTemplate::make();
    // 加自己额外的步骤
    std::cout << "Coffee is made." << std::endl;
}

3.3  具体实现类：茶

#ifndef TEA_H
#define TEA_H

#include "idrinktemplate.h"

// 具体实现类，实现抽象类中所定义的抽象方法和钩子方法，
// 它们是一个顶级逻辑的一个组成步骤。
class Tea : public IDrinkTemplate
{
public:
    Tea();

    // 重写父类抽象方法
    // 煮开水
    void boilWater()    override;
    // 冲泡
    void brew()         override;
    // 倒入杯中
    void poulInCup()    override;
    // 加料
    void addSomething() override;

    // 可以重写父类模板方法，加上自己的一些内容
    void make() override;
};

#endif // TEA_H

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

Tea::Tea()
{

}

void Tea::boilWater()
{
    std::cout << "Boiled mineral water." << std::endl;
}

void Tea::brew()
{
    std::cout << "Brewing tea." << std::endl;
}

void Tea::poulInCup()
{
    std::cout << "Pour into a teacup." << std::endl;
}

void Tea::addSomething()
{
    std::cout << "Add tea to tea." << std::endl;
}

void Tea::make()
{
    // 调用父类方法
    IDrinkTemplate::make();
    // 加自己额外的步骤
    std::cout << "Tea is made." << std::endl;
}

3.4、调用例子 

#include <iostream>
#include "coffee.h"
#include "tea.h"

int main()
{
    //模板方法（Template Method）模式的定义如下：
    //定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，
    //使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。

    IDrinkTemplate * pCoffee = new Coffee();
    // 模板方法调用
    pCoffee->make();
    delete pCoffee;

    std::cout << std::endl;

    IDrinkTemplate * pTea = new Tea();
    // 模板方法调用
    pTea->make();
    delete pTea;

    return 0;
}

 

模式的应用场景

模板方法模式通常适用于以下场景。

1. 算法的整体步骤很固定，但其中个别部分易变时，这时候可以使用模板方法模式，将容易变的部分抽象出来，供子类实现。
2. 当多个子类存在公共的行为时，可以将其提取出来并集中到一个公共父类中以避免代码重复。首先，要识别现有代码中的不同之处，并且将不同之处分离为新的操作。最后，用一个调用这些新的操作的模板方法来替换这些不同的代码。
3. 当需要控制子类的扩展时，模板方法只在特定点调用钩子操作，这样就只允许在这些点进行扩展。