C++设计模式----模板方法模式

由遇到的问题引出模板方法模式

在面向对象系统的分析与设计过程中经常会遇到这样一种情况：对于某一个业务逻辑（算法实现）在不同的对象中有不同的细节实现，但是逻辑（算法）的框架（或通用的应用算法）是相同的。模板方法提供了这种情况的一个实现框架。

模板方法模式是采用继承的方式实现这一点：将逻辑（算法）框架放在抽象基类中，并定义好细节的接口，子类中实现细节。【注释 1】

【注释 1】：Strategy 模式解决的是和模板方法模式类似的问题，但是 Strategy 模式是将逻辑（算法）封装到一个类中，并采取组合（委托）的方式解决这个问题。

模式选择

解决 2.1 中问题可以采取两种模式来解决，一是模板方法模式，二是 Strategy 模式。本文当给出的是模板方法模式。一个通用的模板方法模式的结构图为：

图 2-1：模板方法模式结构图

模板方法模式实际上就是利用面向对象中多态的概念实现算法实现细节和高层接口的松耦合。可以看到模板方法模式采取的是继承方式实现这一点的，由于继承是一种强约束性的条件，因此也给模板方法模式带来一些许多不方便的地方（有关这一点将在讨论中展开）。

模板方法模式的实现

完整代码示例（code）：模板方法模式的实现很简单，这里为了方便初学者的学习和参考，将给出完整的实现代码（所有代码采用 C++实现，并在 VC 6.0 下测试运行）。

代码片断 1：Template.h

//Template.h
#ifndef _TEMPLATE_H_
#define _TEMPLATE_H_
class AbstractClass{
    public:
    virtual ~AbstractClass();
    void TemplateMethod();
    protected:
    virtual void PrimitiveOperation1() = 0;
    virtual void PrimitiveOperation2() = 0;
    AbstractClass();
    private:
};
class ConcreteClass1:public AbstractClass{
    public:
    ConcreteClass1();
    ~ConcreteClass1();
    protected:
    void PrimitiveOperation1();
    void PrimitiveOperation2();
    private:
};
class ConcreteClass2:public AbstractClass{
    public:
     ConcreteClass2();
    ~ConcreteClass2();
    protected:
    void PrimitiveOperation1();
    void PrimitiveOperation2();
    private:
};
#endif //~_TEMPLATE_H_

代码片断 2：Template.cpp

#include "Template.h"
#include <iostream>
using namespace std;
AbstractClass::AbstractClass(){
}
AbstractClass::~AbstractClass(){
}
void AbstractClass::TemplateMethod(){
     this->PrimitiveOperation1();
    this->PrimitiveOperation2();
}
ConcreteClass1::ConcreteClass1(){
}
ConcreteClass1::~ConcreteClass1(){
}
void ConcreteClass1::PrimitiveOperation1(){
    cout<<"ConcreteClass1...PrimitiveOperat
    ion1"<<endl;
}
void ConcreteClass1::PrimitiveOperation2(){
    cout<<"ConcreteClass1...PrimitiveOperat
    ion2"<<endl;
}
ConcreteClass2::ConcreteClass2(){
}
ConcreteClass2::~ConcreteClass2(){
}
void ConcreteClass2::PrimitiveOperation1(){
cout<<"ConcreteClass2...PrimitiveOperat
ion1"<<endl;
}
void ConcreteClass2::PrimitiveOperation2(){
    cout<<"ConcreteClass2...PrimitiveOperat
    ion2"<<endl;
}

代码片断 3：main.cpp

#include "Template.h"
#include <iostream>
using namespace std;
int main(int argc,char* argv[]){
    AbstractClass* p1 = new ConcreteClass1();
    AbstractClass* p2 = new ConcreteClass2();
    p1->TemplateMethod();
    p2->TemplateMethod();
    return 0;
}

代码说明：由于模板方法模式的实现代码很简单，因此解释是多余的。其关键是将通用算法（逻辑）封装起来，而将算法细节让子类实现（多态）。

唯一注意的是我们将原语操作（细节算法）定义未保护（Protected）成员，只供模板方法调用（子类可以）。

关于模板方法的讨论

模板方法模式是很简单模式，但是也应用很广的模式。如上面的分析和实现中阐明的模板方法是采用继承的方式实现算法的异构，其关键点就是将通用算法封装在抽象基类中，并将不同的算法细节放到子类中实现。

模板方法模式获得一种反向控制结构效果，这也是面向对象系统的分析和设计中一个原则 DIP（依赖倒置：Dependency Inversion Principles）。其含义就是父类调用子类的操作（高层模块调用低层模块的操作），低层模块实现高层模块声明的接口。这样控制权在父类（高层模块），低层模块反而要依赖高层模块。

继 承 的 强 制 性 约 束 关 系 也 让模板方法模 式 有 不 足 的 地 方 ， 我 们 可 以 看 到 对 于ConcreteClass 类中的实现的原语方法 Primitive1()，是不能被别的类复用。假设我们要创建一个 AbstractClass 的变体 AnotherAbstractClass，并且两者只是通用算法不一样，其原语操作想复用 AbstractClass 的子类的实现。但是这是不可能实现的，因为 ConcreteClass 继承自AbstractClass，也就继承了 AbstractClass 的通用算法，AnotherAbstractClass 是复用不了ConcreteClass 的实现，因为后者不是继承自前者。

模板方法模式暴露的问题也正是继承所固有的问题，策略模式则通过组合（委托）来达到和模板方法模式类似的效果，其代价就是空间和时间上的代价，关于策略模式的详细讨论请参考 Strategy 模式解析。