动机

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

    模式定义

    定义一个操作中的算法的骨架（稳定），而将一些步骤（变化）延迟到子类中。Template Method 使得子类可以复用一个算法的结构既可重定义（override 重写）该算法的某些特定步骤。

    未使用该设计模式

    1. // 程序库开发人员
    2. class Library {
    3. public:
    4.   void Step1() {
    5.       // ...
    6.   }
    7.   void Step3() {
    8.       // ...
    9.   }
    10.   void Step5() {
    11.       // ...
    12.   }
    13. }
    ```cpp // 应用程序开发人员 class Application { public: bool Step2() {
    1.   // ...
    } void Step4() {
    1.   // ...
    } }

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

  1. lib.Step1();
  3. if(app.Step2()) {
  4.     lib.Step3();
  5. }
  7. for(int i = 0; i < 4; i++) {
  8.     app.Step4();
  9. }
  11. lib.Step5();

}

  1. <a name="zCCQU"></a>
  2. ### 实现2
  3. ```cpp
  4. // 程序库开发人员
  5. // 程序库开发人员将稳定Run流程写出来，
  6. class Library {
  7. public:
  8.     //稳定 template method
  9.     void Run() {
  10.         Step1();
  11.         if (Step2()) {    //支持变换-->虚函数的多态调用
  12.             Step3();
  13.         }
  14.         for(int i = 0; i<4; i++) {
  15.             Step4();    //支持变换-->虚函数的多态调用
  16.         }
  17.         Step5();
  18.     }
  20.     virtual ~Library() { }
  21. protected:
  22.     void Step1() {    //稳定
  23.         // ...
  24.     }
  25.     void Step3() {    //稳定
  26.         // ...
  27.     }
  28.     void Step5() {    //稳定
  29.         // ...
  30.     }
  32.     virtual bool Step2() = 0;    //变化（不做实现）
  33.     virtual bool Step4() = 0;    //变化
  34. };
  1. // 应用程序开发人员
  2. class Application : public Library {
  3. protected:
  4.     virtual bool Step2() {
  5.         //... 子类重写实现
  6.     }
  7.     virtual void Step4() {
  8.         //... 子类重写实现
  9.     }
  10. };
  12. int main()
  13. {
  14.     Library * plib = new Application();
  15.     lib->Run();
  17.     delete plib;
  18. }

对比