模板方法模式（C++实现）

（本博客旨在个人总结回顾）

1、详情：

策略模式：定义一个操作中的算法骨架，将一些步骤延时到子类中。模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。

说明：

主要解决：

一些方法通用，却在每一个子类都重新写了这一方法。

优点： 

①封装不变部分，扩展可变部分。

②提取公共代码，便于维护。

③行为由父类控制，子类实现。

缺点：

每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。

使用场景： 

①有多个子类共有的方法，且逻辑相同。

②重要的、复杂的方法，可以考虑作为模板方法。

2.1、UML类图：

 

2.2、例子源码

stdafx.h

// stdafx.h : 标准系统包含文件的包含文件，
// 或是经常使用但不常更改的
// 特定于项目的包含文件
//

#pragma once

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>

#include <iostream>
using namespace std;

// TODO:  在此处引用程序需要的其他头文件

AbstractClass.h

#pragma once

class AbstractClass
{
public:
    AbstractClass();
    virtual ~AbstractClass();

public:
    virtual void Operation1() = 0;
    virtual void Operation2() = 0;
    void TemplateMethod();
};

AbstractClass.cpp

#include "stdafx.h"
#include "AbstractClass.h"

AbstractClass::AbstractClass()
{
}

AbstractClass::~AbstractClass()
{
}

void AbstractClass::TemplateMethod()
{
    Operation1();
    Operation2();
}

ClassX.h

#pragma once
#include "AbstractClass.h"

class ClassX :
    public AbstractClass
{
public:
    ClassX();
    ~ClassX();

public:
    void Operation1();
    void Operation2();
};

ClassX.cpp

#include "stdafx.h"
#include "ClassX.h"

ClassX::ClassX()
{
}

ClassX::~ClassX()
{
}

void ClassX::Operation1()
{
    cout << "具体类X操作1实现！" << endl;
}

void ClassX::Operation2()
{
    cout << "具体类X操作2实现！" << endl;
}

ClassY.h

#pragma once
#include "AbstractClass.h"

class ClassY :
    public AbstractClass
{
public:
    ClassY();
    ~ClassY();

public:
    void Operation1();
    void Operation2();
};

ClassY.cpp

#include "stdafx.h"
#include "ClassY.h"

ClassY::ClassY()
{
}

ClassY::~ClassY()
{
}

void ClassY::Operation1()
{
    cout << "具体类Y操作1实现！" << endl;
}

void ClassY::Operation2()
{
    cout << "具体类Y操作2实现！" << endl;
}

调用代码

TemplateMethodPatternMemo.cpp

// TemplateMethodPatternMemo.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "AbstractClass.h"
#include "ClassX.h"
#include "ClassY.h"

int _tmain(int argc, _TCHAR* argv[])
{
    AbstractClass* pAbstractClass = new ClassX();
    pAbstractClass->TemplateMethod();
    delete pAbstractClass;

    pAbstractClass = new ClassY();
    pAbstractClass->TemplateMethod();
    delete pAbstractClass;

    system("pause");
    return 0;
}

2.3、运行结果：