cppopp

算法意圖：

將算法骨架定義在父類當中，具體的實現放到子類當中。Template method可以不改變算法的骨架在子類中重新定義算法中的某些特定的步驟。

算法適用性：

1.       一次性將算法的不變部分封裝到父類當中，將可變的部分放到子類中去實現。

2.       各子類的公共部分亞冠提取出來放到父類當中，避免代碼重復，分離變化和不變的地方。

3.       通過hook來控制子類的擴展。

4.       模板方法的格式:
class TemplateMethod_Demo
{
  public:
    <返回值類型> <模板方法名>(<參數列表>); //模板方法成員函數,定義為公有的非虛成員函數,供客戶調用;
  protected:
    virtual <返回值類型> <抽象操作的方法名>(<參數列表>) = 0;//抽象操作(可選),即:原語操作,用純虛函數表示,必須被重定義,定義為保護類型的,只能被模板方法本身調用;
    virtual <返回值類型> <鉤子操作的方法名>(<參數列表>){};  //鉤子操作(必選),即:原語操作,用虛函數表示,可被重定義,提供缺省實現,定義為保護類型的,只能被模板方法本身調用;
};

  1// template.cpp : 定義控制臺應用程序的入口點。
  2//
  3
  4#include "stdafx.h"
  5#include<iostream>
  6using namespace std;
  7
  8class AbstractClass
  9{
 10public:
 11     AbstractClass(){}
 12     virtual ~AbstractClass(){}
 13     virtual void doFirst();
 14     virtual void doAfter();
 15     // 這個函數中定義了算法的輪廓
 16     void TemplateMethod()
 17     {
 18         doFirst();
 19         PrimitiveOperation1();
 20         PrimitiveOperation2();
 21          if (b_jugle) 
 22          {
 23              doSthElse();
 24          } 
 25         doAfter();
 26     }
 27     virtual void setHookTrue()
 28     {
 29         AbstractClass::b_jugle = true;
 30     };
 31
 32protected:
 33     // 純虛函數,由派生類實現之
 34     virtual void PrimitiveOperation1() = 0;
 35     virtual void PrimitiveOperation2() = 0;
 36     virtual void  doSthElse() = 0;
 37     static bool b_jugle;
 38     
 39     
 40};
 41
 42bool AbstractClass::b_jugle = false;
 43
 44
 45void AbstractClass::doFirst()
 46{
 47    cout<<"do std before"<<endl;
 48}
 49
 50void AbstractClass::doAfter()
 51{
 52    cout<<"do std after"<<endl;
 53}
 54
 55// 繼承自AbstractClass,實現算法
 56class ConcreateClass: public AbstractClass
 57{
 58public:
 59     ConcreateClass(){}
 60     virtual ~ConcreateClass(){}
 61
 62protected:
 63     virtual void PrimitiveOperation1()
 64     {
 65         cout << "PrimitiveOperation1 by ConcreateClass\n";
 66     }
 67     virtual void PrimitiveOperation2()
 68     {
 69         cout << "PrimitiveOperation2 by ConcreateClass\n";
 70     }
 71     virtual void doSthElse()
 72     {
 73         cout<<"so something else!\n"<<endl;
 74     }
 75};
 76
 77
 78// 繼承自AbstractClass,實現算法
 79class ConcreateClassNew: public AbstractClass
 80{
 81public:
 82     ConcreateClassNew(){}
 83     virtual ~ConcreateClassNew(){}
 84    
 85protected:
 86     virtual void PrimitiveOperation1()
 87     {
 88         cout << "PrimitiveOperation1 by ConcreateClassNew\n";
 89     }
 90     virtual void PrimitiveOperation2()
 91     {
 92         cout << "PrimitiveOperation2 by ConcreateClassNew\n";
 93     }
 94      virtual void doSthElse()
 95     {
 96         cout<<"so something else!\n"<<endl;
 97     }
 98    
 99};
100
101
102int _tmain(int argc, _TCHAR* argv[])
103{
104    AbstractClass* pConcreateClass = new ConcreateClass;
105    pConcreateClass->TemplateMethod();
106    delete pConcreateClass;
107
108
109    AbstractClass* pConcreateClass2 = new ConcreateClassNew;
110    pConcreateClass2->setHookTrue();
111    pConcreateClass2->TemplateMethod();
112    delete pConcreateClass2;
113    return 0;
114}
115
116

運行結果：

template method的設計原則：
1.封裝變化部分；
2.對接口編程
3. 好萊塢原則：別調用我們，在我們需要時會調用你

最后談一下和策略模式的區別，最主要的區別是一個是使用繼承而策略模式是使用組合方式。