Template模式

在开发时，有时会遇到对于一个算法的实现，在不同的对象中有不同的实现，可是这个算法的框架是同样的。这时能够使用Template模式或Strategy模式。

Template是採用继承的方式来实现这一点，即将算法框架放在抽象基类中，在基类定义好接口。之后在派生类实现算法。

类图结构如图所看到的：

//Template.h

#ifndef _TEMPLATE_H_
#define _TEMPLATE_H_

class AbstractClass
{
public:
    virtual ~AbstractClass();
    void TemplateMethod();
protected:
    virtual void PrimitiveOperation() = 0;
};

class ConcreteClass1 :public AbstractClass
{
public:
    ConcreteClass1();
    ~ConcreteClass1();
    void PrimitiveOperation();
};
class ConcreteClass2 :public AbstractClass
{
public:
    ConcreteClass2();
    ~ConcreteClass2();
    void PrimitiveOperation();
};
#endif

//Template.cpp

//Template.cpp

#include"Template.h"
#include<iostream>
using namespace::std;

AbstractClass::~AbstractClass()
{}
void AbstractClass::TemplateMethod()
{
    PrimitiveOperation();
}

ConcreteClass1::ConcreteClass1()
{}
ConcreteClass1::~ConcreteClass1()
{}
void ConcreteClass1::PrimitiveOperation()
{
    cout << "ConcreteClass1 PrimitiveOperation()" << endl;
}

ConcreteClass2::ConcreteClass2()
{}
ConcreteClass2::~ConcreteClass2()
{}
void ConcreteClass2::PrimitiveOperation()
{
    cout << "ConcreteClass2 PrimitiveOperation()" << endl;
}

//main.cpp

//main.cpp

#include"Template.h"

int main()
{
    AbstractClass* p1 = new ConcreteClass1();
    AbstractClass* p2 = new ConcreteClass2();
    p1->TemplateMethod();
    p2->TemplateMethod();

    return 0;
}

Template模式的关键是将算法抽象封装在基类中，并在不同的派生类中实现。

Template模式获得了一个反向控制结构的效果，即依赖倒置原则。即在父类调用子类的操作（高层模块调用底层模块的操作），底层模块实现高层模块声明的接口。所以控制权在高层模块（父类）。底层模块要依赖高层模块。

Template模式也有缺点，继承是一种强制约束关系。比如在ConcreteClass中实现的方法PrimitiveOperation不能被其它类复用。