C++设计模式<三>：模板方法(Template Method 模式)

模式分类

1. GOF-23模式分类

1. 从目的来看：
   
   • 创建型(Creational)模式：将对象的部分创建工作延迟到子类或其他对象，从而应对需求变化为创建时类型实现引来的冲击
   • 结构性(structural)模式:通过类继承或对象组合获得更灵活的结构，从而应对需求变化为对象的结构带来的冲击
   • 行为性(behavioral)模式:通过对类继承或对象组合来划分类与对象间的职责，从而应对需求变化为多个交互的对象带来的冲击
2. 从范围来看：
   
   • 类模式处理类与子类之间的静态关系(继承方案)
   • 对象模式处理对象间的动态关系(组合方案)

2. 从封装变化角度对模式分类

3. 重构获得模式Refactoring to Patterns

1. 面向对象设计模式是“好的面向对象设计”，所谓“好的面向对象设计”指的是那些可以满足“应对变化，提高复用”的设计
2. 现代软件设计的特征是“需求的频繁变化”。设计模式的要点是“寻求变化点，然后在变化点处应用设计模式，从而来更好地应对需求的变化”，“什么时候，什么地点应用设计模式”比“理解设计模式结构本身”更重要
3. 设计模式的应用不宜先入为主，一上来就使用设计模式是对设计模式的最大误用。没有一步到位的设计模式。敏捷软件开发实践提倡的“Refactoring to Patterns” 是目前普遍公认的最好的使用设计模式的方法

就是说学习不要一上来就想着用那种设计模式，而是通过分析重构代码来使用学习设计模式，从而比较其优缺点。

4. 重构关键技法

• 静态->动态
• 早绑定->晚绑定
• 继承->组合
• 编译时依赖->运行时依赖
• 紧耦合->松耦合

5. “组件协作”模式

现代软件专业分工后的第一个结果是“框架(或库)与应用程序的划分”，“组件协作”模式通过晚期绑定，来实现框架与应用程序之间的松耦组合，是二者之间协作时常用的模式
就是说：先入境写应用程序时，一般会使用框架或lib来实现app，因此要处理好自己写的逻辑与框架或lib之间的关系。

Template Method模式

1.动机

• 在软件稳定构建过程中，对于一项任务，常有稳定的整体操作结构，但各个子步骤却有很多改变的需求，或者由于固定的原因而无法和任务的整体结构同时实现。
• 如何确定稳定操作结构的前提下，来灵活应对各个子步骤的变化或晚期实现需求

先看结构化软件解决方法，伪代码如下

//程序库开发人员
class Library{
public:
    void Step1(){
        //...
    }
    void Step3(){
        //...
    }
    void Step5(){
        //...
    }
};

//应用程序开发人员
class Application{
public:
    bool Step2(){
        //...
    }
    void Step4(){
        //...
    }
};

int main()
{
    Library lib();
    Application app();

    lib.Step1();

    if (app.Step2()){
        lib.Step3();
    }

    for (int i = 0; i < 4; i++){
        app.Step4();
    }

    lib.Step5();

}
/*
这是一种结构化软件设计流程，lib开发人员开发1,3,5步骤；然后app开发人员开发2,4步骤，然后去写程序主程序
*/

然而其实这个主程序流程是稳定的，因此有了以下面向对象软件设计流程
伪代码

//程序库开发人员
class Library{
public:
    //稳定 template method
    void Run(){
        Step1();
        if (Step2()) { //支持变化 ==> 虚函数的多态调用
            Step3(); 
        }
        for (int i = 0; i < 4; i++){
            Step4(); //支持变化 ==> 虚函数的多态调用
        }
        Step5();
    }
    virtual ~Library(){ }  //C++基类，虚析构函数，delete的时候会调到其正确的虚析构函数。

protected:

    void Step1() { //稳定
        //.....
    }
    void Step3() {//稳定
        //.....
    }
    void Step5() { //稳定
        //.....
    }
    virtual bool Step2() = 0;//变化
    virtual void Step4() =0; //变化
};

//应用程序开发人员
class Application : public Library {
protected:
    virtual bool Step2(){
        //... 子类重写实现
    }

    virtual void Step4() {
        //... 子类重写实现
    }
};

int main()
    {
        Library* pLib=new Application(); //多态指针
        lib->Run();

        delete pLib;
    }
}
/*
其中由于程序整体流程结构是稳定的，lib开发人员开发1,3,5三个步骤，并开发程序主流程；app开发人员开发2,4两个步骤。
*/

2. 早绑定和晚绑定

一个晚实现的东西调用一个早实现的东西，这个就叫早绑定非常主流的一种做法，如C语言一般这样做；反过来调用就是晚绑定。
C++晚绑定机制：虚函数，函数指针。

3. template模式定义

定义一个操作中的算法的骨架(稳定),而将一些步骤延迟(变化)到子类中，Template Method使得子类可以不改变(复用)一个算法的结构即可重定义(overwrite重写)该算法的某些特定模式

延迟到子类：就是定义一个虚函数，让子类去实现其虚函数。

4. 结构

其中TempalteMethod()是稳定的，而PrimitiveOperation1()，PrimitiveOperation2()是变化的。

5. 总结

• template method模式是一种非常基础的设计模式，在面向对象系统中存在大量的应用，它用最简洁的机制(虚函数的多态性)为很多应用程序框架提供了灵活的扩展点，是代码复用的基本实现结构
• 除了可以灵活应对子步骤的变化外，“不要调用我，让我来调用你”的反响控制结构是template method的典型应用
• 在具体实现方面，被template method调用的虚方法可以具有实现，也可以没有任何实现(抽象方法，纯虚方法)，但一般推荐将他们设置为protected方法。
  why protected?单独作为一个方法是没有意义的，只有作为一个流程的时才是有意义的，
  稳定中有变化。前提条件run()必须稳定，否则template方法就不成立了。

设计模式补充

1. 设计模式的假设条件：有一个稳定点，当然当所有都是稳定的或所有都是变化的，设计模式也没有意义；
2. 设计模式：在稳定(相对稳定)和变化寻求一个隔离点；
3. 一个正常的体系结构：有变化有稳定；
4. 绝大多数的框架里都有这个tempalte方法；
5. 有个缺点：父类把步骤封装的很好了，子类只需要实现一些简单特定的东西，甚至连main程序都看不到(MFC中就是这样)，这样如果我们需要学习就得去了解这个lib的流程
6. 看任何一个设计模式：那些事稳定的，那些是变化的。