Template 模式-GoF 23 种设计模式精解系列-附 C++实现源码

前言

尊重原创，本系列文本解析部分主要基于Candidate for Master’s Degree School of Computer Wuhan University的K_Eckel（[email protected]）《设计模式精解-GoF 23 种设计模式解析附 C++实现源码》。为了避免重造轮子，本系列博文对源码在ubuntu16.04下做了验证并上传到了gitee，再次感谢。

如有问题，可邮件联系我([email protected])并共同探讨解决方案。

Template 模式简介：

在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。
定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
比如在造房子的时候，地基、走线、水管都一样，只有在建筑的后期才有加壁橱加栅栏等差异；西游记里面菩萨定好的 81 难，这就是一个顶层的逻辑骨架。

问题

在面向对象系统的分析与设计过程中经常会遇到这样一种情况：对于某一个业务逻辑（算法实现）在不同的对象中有不同的细节实现，但是逻辑（算法）的框架（或通用的应用算法）是相同的。Template提供了这种情况的一个实现框架。
Template模式是采用继承的方式实现这一点：将逻辑（算法）框架放在抽象基类中，并定义好细节的接口，子类中实现细节。^{【注释1】}

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

模式选择

上述问题可以采取两种模式来解决，一是Template模式，二是Strategy模式。本文当给出的是Template模式。一个通用的Template模式的结构图为：
Template Pattern
图 1:Template 模式结构示意图 1

实现

完整代码示例(code)

Template模式的实现很简单，这里为了方便初学者的学习和参考，将给出完整的实现代码(所有代码采用 C++实现,并在 Visual Studio Code，Version: 1.36.1 下测试运行)。

源码gitee地址：点击这里

代码目录结构：

PS C:\Users\guopz\Desktop\GiteeBlog\designpatternsbycpipei\behavioralPattern\Template> tree /F    
卷 Windows 的文件夹 PATH 列表
卷序列号为 F0C5-AFA6
C:.
├─include
│      Template.h
│      
└─src
        a.out
        main.cpp
        Template.cpp
        
PS C:\Users\guopz\Desktop\GiteeBlog\designpatternsbycpipei\behavioralPattern\Template>

Template.h:

// Template.h
#ifndef _TEMPLATE_H_
#define _TEMPLATE_H_

class AbstractClass {
 private:
  /* data */

 protected:
  virtual void PrimitiveOperation1() = 0;
  virtual void PrimitiveOperation2() = 0;
  AbstractClass();

 public:
  void TemplateMethod();
  virtual ~AbstractClass();
};

class ConcreteClass1 : public AbstractClass {
 private:
  /* data */

 protected:
  void PrimitiveOperation1();
  void PrimitiveOperation2();

 public:
  ConcreteClass1(/* args */);
  ~ConcreteClass1();
};

class ConcreteClass2 : public AbstractClass {
 private:
  /* data */

 protected:
  void PrimitiveOperation1();
  void PrimitiveOperation2();

 public:
  ConcreteClass2(/* args */);
  ~ConcreteClass2();
};

#endif  //~ TEMPLATE H

Template.cpp:

// Template.cpp

#include "../include/Template.h"
#include <iostream>

using namespace std;

AbstractClass::AbstractClass(/* args */) {}
AbstractClass::~AbstractClass() {}
void AbstractClass::TemplateMethod() {
  this->PrimitiveOperation1();
  this->PrimitiveOperation2();
}

ConcreteClass1::ConcreteClass1(/* args */) {}
ConcreteClass1::~ConcreteClass1() {}
void ConcreteClass1::PrimitiveOperation1() { printf("ConcreteClass1...PrimitiveOperation1 \n"); }
void ConcreteClass1::PrimitiveOperation2() { printf("ConcreteClass1...PrimitiveOperation2 \n"); }

ConcreteClass2::ConcreteClass2(/* args */) {}
ConcreteClass2::~ConcreteClass2() {}
void ConcreteClass2::PrimitiveOperation1() { printf("ConcreteClass2...PrimitiveOperation1 \n"); }
void ConcreteClass2::PrimitiveOperation2() { printf("ConcreteClass2...PrimitiveOperation2 \n"); }

main.cpp:

// main.cpp

#include <iostream>
#include "../include/Template.h"

using namespace std;

int main(int argc, char* argv[]) {
  AbstractClass* p1 = new ConcreteClass1();
  AbstractClass* p2 = new ConcreteClass2();
  p1->TemplateMethod();
  p2->TemplateMethod();

  return 0;
}

代码说明

由于Template模式的实现代码很简单，因此解释是多余的。其关键是将通用算法（逻辑）封装起来，而将算法细节让子类实现（多态）。
唯一注意的是我们将原语操作（细节算法）定义未保护（Protected）成员，只供模板方法调用（子类可以）。

编译运行结果：

PS C:\Users\guopz\Desktop\GiteeBlog\designpatternsbycpipei\behavioralPattern\Template\src> g++ *.cpp -std=c++11
PS C:\Users\guopz\Desktop\GiteeBlog\designpatternsbycpipei\behavioralPattern\Template\src> .\a.exe
ConcreteClass1...PrimitiveOperation1
ConcreteClass1...PrimitiveOperation2
ConcreteClass2...PrimitiveOperation1
ConcreteClass2...PrimitiveOperation2
PS C:\Users\guopz\Desktop\GiteeBlog\designpatternsbycpipei\behavioralPattern\Template\src>

讨论

Template模式是很简单模式，但是也应用很广的模式。如上面的分析和实现中阐明的Template是采用继承的方式实现算法的异构，其关键点就是将通用算法封装在抽象基类中，并将不同的算法细节放到子类中实现。
Template模式获得一种反向控制结构效果，这也是面向对象系统的分析和设计中一个原则DIP（依赖倒置：Dependency Inversion Principles）。其含义就是父类调用子类的操作（高层模块调用低层模块的操作），低层模块实现高层模块声明的接口。这样控制权在父类（高层模块），低层模块反而要依赖高层模块。
继承的强制性约束关系也让Template模式有不足的地方，我们可以看到对于ConcreteClass类中的实现的原语方法Primitive1()，是不能被别的类复用。假设我们要创建一个AbstractClass的变体AnotherAbstractClass，并且两者只是通用算法不一样，其原语操作想复用AbstractClass的子类的实现。但是这是不可能实现的，因为ConcreteClass继承自AbstractClass，也就继承了AbstractClass的通用算法，AnotherAbstractClass是复用不了ConcreteClass的实现，因为后者不是继承自前者。
Template模式暴露的问题也正是继承所固有的问题，Strategy模式则通过组合（委托）来达到和Template模式类似的效果，其代价就是空间和时间上的代价，关于Strategy模式的详细讨论请参考Strategy模式解析。

前言

目录

创建型模式(Creating Pattern)

结构型模式（Structrual Pattern）

行为型模式（Behavioral Pattern）