模板模式（template）
在面向对象系统的设计和开发过程中，一定会有这样的情况：对于一些功能，在不同的对象身上展示不同的作用，但是功能的框架是一样的，这就是模板（template）模式的用武之地，我说的不知道你有没有理解，一会代码展示的时候，你就会一目了然，代码很简单。
在template模式中，采用的是继承的方式实现上述的内容。
template模式的结构图：

对于template模式的实现就是运用了多态的概念，对于不同的子类赋值给父类，父类表现出的形式是不同的。
看简单的实现代码：
#include
using namespace std;

class abstractClass
{
 
public:
     void TemplateMethod();
//   virtual ~abstractClass(); //虚析构

protected:
//    abstractClass();
    virtual void Test1()=0;//纯虚函数
    virtual void Test2()=0;

};

class testClass1:public abstractClass
{
//     public:
//         testClass1();
//         ~testClass1();
    protected:
        void Test1();
        void Test2();

};
class testClass2:public abstractClass
{
// public:
//     testClass2();
//     ~testClass2();
protected:
    void Test1();
    void Test2();
};

void abstractClass::TemplateMethod()
{
    Test1();
    Test2();
}
void testClass1::Test1()
{
    cout<<"testClass1's test1"<<endl;
}
void testClass1::Test2()
{
    cout<<"testClass1's test2"<<endl;
}

void testClass2::Test1()
{
    cout<<"testClass2's test1"<<endl;
}
void testClass2::Test2()
{
    cout<<"testClass2's test2"<<endl;
}

int main()
{
    abstractClass *a=new testClass1();
    abstractClass *b=new testClass2();
    //abstractClass *c=new abstractClass(); 此方法是不行的，因为其为抽象类
    a->TemplateMethod();
    b->TemplateMethod();
    //c->TemplateMethod();
    return 0;
}
对于template模式，相信大家通过简单的代码实现可以理解了吧！
正像前面说的那样：
template是采用继承的方式实现功能的不同，其关键点就是将通用功能封装在抽象基类中，并将不同的功能细节放到子类中实现。采用一种称为：DIP（依赖倒置：Dependency Inversion Principles），就是父类去调用子类的功能，高层去控制底层，底层为高层的需要做基础，以实现不同的功能展示。在template模式中，采用的是继承的方式实现上述的内容，看到继承后，脑海里会出现一句话：尽量采用组合，少用继承。高内聚，低耦合的存在导致继承 的用武之地有所限制，因为继承增加了模块与模块之间的耦合度。所以从这一方面(继承)可看出，template模式是有一定的限制的。比如上面代码里的testClass1类的实现是不能被其他的类（除了自己的父类）复用的，假设我们要创建一个与abstractClass的很相似的类abstractClass1，对于abstractClass1是复用不了testClass1的实现，因为后者不是继承的前者，因为两者没有任何的关系。但是我们确实需要这么一个abstractClass1类怎么办呢？这是我们以后所要学习的策略（Strategy）模式所要解决的问题。