15.模板模式--Template

 

Template模式：
Template模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。我们既然是用了继承，并且肯定这个继承有意义，就应该要成为子类的模板，所有重复的代码都应该要上升到父类去，而不是让每个子类都去重复。Template模式实际上就是利用面向对象中多态的概念实现算法实现细节和高层接口的松耦合。可以看到Template模式采取的是继承方式实现这一点的。

当我们要完成在某一细节层次一致的一个过程或一系列步骤，但其个别步骤在更详细的层次上的实现可能不同是，我们通常考虑用模板方法模式来处理。

通用的Template模式的结构图为：
 

下面是Template模式的实现代码：

//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 //~TEMPLATEH

//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...PrimitiveOperation1"<<endl;
}
void ConcreteClass1::PrimitiveOperation2()
{
    cout<<"ConcreteClass1...PrimitiveOperation2"<<endl;
}
ConcreteClass2::ConcreteClass2()
{
}
ConcreteClass2::~ConcreteClass2()
{
}
void ConcreteClass2::PrimitiveOperation1()
{
    cout<<"ConcreteClass2...PrimitiveOperation1"<<endl;
}
void ConcreteClass2::PrimitiveOperation2()
{
    cout<<"ConcreteClass2...PrimitiveOperation2"<<endl;
}

// 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;
}

下面是Template模式和Strategy模式的优缺点对比。
Template模式（继承）的优点：
1）易于修改和扩展那些被复用的实现。
Template模式（继承）的缺点：
1）破坏了封装性，继承中父类的实现细节暴露给子类了；
2）“白盒”复用，原因在1）中；
3）当父类的实现更改时，其所有子类将不得不随之改变
4）从父类继承而来的实现在运行期间不能改变（编译期间就已经确定了）。

Strategy模式（组合）的优点：
1）“黑盒”复用，因为被包含对象的内部细节对外是不可见的；
2）封装性好，原因为1）；
3）实现和抽象的依赖性很小（组合对象和被组合对象之间的依赖性小）；
4）可以在运行期间动态定义实现（通过一个指向相同类型的指针，典型的是抽象基类的指针）。
Strategy模式（组合）的缺点：
1）系统中对象过多。