定义算法的框架 - 模板方法模式-优快云博客

本文链接：https://blog.youkuaiyun.com/lms1008611/article/details/107706656

模板方法设计模式是软件开发中的一种常见模式，用于在稳定的操作结构中处理变化的子步骤。通过定义一个操作的骨架，将变化部分留给子类实现，从而实现代码的复用和扩展。例如，请客吃饭的场景，稳定部分如进店、吃饭、买单和离开，变化部分是点菜。通过模板方法模式，可以将稳定部分封装在父类，将点菜的实现留给不同的子类（如员工、老板、客户），提高代码的可扩展性和复用性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

现代软件专业分工之后的第一个结果是“框架与应用程序的划分”，“组件协作”模式通过晚期绑定，来实现框架与应用程序之间的松耦合，是二者之间协作时常用的模式。

“组件协作” 模式通常包含
   1、模板方法模式
   2、观察者模式
   3、策略模式

这篇文章中我们首先来了解模板方法模式，其他两个模式在后续的文章中了解熟悉。

只要写过面向对象的程序，用过一些框架，都会使用过模板方法模式，比方QT中实现线程，那么我们一般会编写一个继承QThread的子类，然后在子类中重写run函数，这就是模板方法模式。

动机：

在软件构建过程中，对于某一项任务，它常常有稳定的整体操作结构，但各个子步骤却有很多改变的需求，或者由于固有的原因(比如框架与应用之间的关系)而无法和任务的整体结构同时实现。

如何在确定稳定操作结构的前提下，来灵活应对各个子步骤的变化或者晚期实现需求？

这里重点标注了稳定、变化两个词，其实在设计模式中，中心思想大部分都是围绕这稳定与变化来展开的，对于稳定的，尽量不去更改，对于有变化需求的，尽量将这些需求与稳定的部分解耦，这就是所谓的提高代码复用与扩展。

为了更好理解上述的话，这里举个例子：请客吃饭
一般我们请客吃饭，常规步骤都是：进饭店 - 点菜 - 吃饭 - 买单 - 离开，这里稳定与变化部分便可以分为：
稳定部分：进饭店、吃饭、买单、离开，整个请客步骤(框架)
变化部分：点菜（不同人请不同的人吃饭，可能点的菜不一样）

如果按常规的流程处理，请员工与请老板流程可能如下：

#include <iostream>

using namespace std;

//员工餐
class Employee
{
public:
    //进饭店
    void enter()
    {
        cout << "进饭店" <<endl;
    }
    //点菜
    void order()
    {
        cout << "点盐焗鸡、啤酒鸭、红烧鱼" <<endl;
    }
    //吃饭
    void eat()
    {
        cout << "吃饭" << endl;
    }
    //买单
    void pay()
    {
        cout << "买单" << endl;
    }
    //离开
    void leave()
    {
        cout << "离开" << endl;
    }
};

//老板餐
class Boss
{
    public:
    //进饭店
    void enter()
    {
        cout << "进饭店" <<endl;
    }
    //点菜
    void order()
    {
        cout << "鱼翅、燕窝、熊掌" <<endl;
    }
    //吃饭
    void eat()
    {
        cout << "吃饭" << endl;
    }
    //买单
    void pay()
    {
        cout << "买单" << endl;
    }
    //离开
    void leave()
    {
        cout << "离开" << endl;
    }
};

int main()
{
    cout << "----------请员工餐----------" << endl;
    Employee e;
    e.enter();
    e.order();
    e.eat();
    e.pay();
    e.leave(); 

    cout << "----------请老板餐----------" << endl;
    Boss b;
    b.enter();
    b.order();
    b.eat();
    b.pay();
    b.leave();
}

从结果来看，只有点菜部分不一样，其余都一样，包括流程(框架)，这种代码是没有复用性，可扩展性也很差，稳定的部分与变动的部分完全耦合到一起，假如要清客户吃饭，那么就要重新实现一遍整个流程，但是实际变化的仅仅是点菜。

为了代码复用与可扩展性，这里我们采用模板方式模式把这个请客系统中，稳定与变化的部分解耦

1、把稳定的部分(进饭店、吃饭、买单、离开，整个请客步骤(框架))封装进一个父类(Dinner)中
2、把变化的部分(点菜)在父类中只留一个接口，具体实现放到子类(员工、老板、客户)中完成
结构图为：

#include <iostream>

using namespace std;

//父类(请客)
class Dinner
{
private:
    //进饭店
    void enter()    //稳定部分
    {
        cout << "进饭店" <<endl;
    }
    //吃饭
    void eat()      //稳定部分
    {
        cout << "吃饭" << endl;
    }
    //买单
    void pay()      //稳定部分
    {
        cout << "买单" << endl;
    }
    //离开
    void leave()    //稳定部分
    {
        cout << "离开" << endl;
    }
protected:
    virtual void order() = 0;   //变化部分在父类中只定义接口，实现由子类实现

public:
    void dinner()   //稳定部分
    {
        enter();
        order();
        eat();
        pay();
        leave();
    }

    virtual ~Dinner()   //父类的析构函数需要定义成虚函数
    {

    }
};

//子类(请员工)
class Employee : public Dinner
{
protected:
    void order()   //子类中实现变动的部分(点菜)
    {
        cout << "点盐焗鸡、啤酒鸭、红烧鱼" <<endl;
    }
};

//子类(请老板)
class Boss : public Dinner
{
protected:
    void order()    //子类中实现变动的部分(点菜)
    {
        cout << "鱼翅、燕窝、熊掌" <<endl;
    }
};

int main()
{
    cout << "----------请员工餐----------" << endl;
    Dinner* pE = new Employee();
    pE->dinner();

    cout << "----------请老板餐----------" << endl;
    Dinner* pB = new Boss();
    pB->dinner();
}