【设计模式一】、模板方法模式

模板方法

简单来说就是父类确定固定的流程，可变部分做为函数交给子类实现

假设我们现有这样两段代码：
库代码 Library.cpp：

// 程序库开发人员
class Library{
public:
	void Step1(){
		//...
	}

    void Step3(){
		//...
    }

    void Step5(){
		//...
    }
};

应用程序代码Application.cpp：

//应用程序开发人员  -- 内部代码
class Application{
public:
	bool Step2(){
		//...
    }

    void Step4(){
		//...
    }
};

int main()
{
	// 假设这段代码是一个固定流程，那这个流程可以封装成一个方法Run()，这样应用开发人员就比较省事了
	// 如果这个Run()是放到库代码里，则Step2和Step4也应该放到Library里
	Library lib();
	Application app();

	lib.Step1();

	if (app.Step2()){
		lib.Step3();
	}

	for (int i = 0; i < 4; i++){
		app.Step4();
	}

	lib.Step5();

}

如果main函数中的流程比较固定，而只有一些数据或动作（如函数）需要变化，则可将这个流程当作模板写入库中（绑定流程）；将并变化部分的数据封装成虚函数，以将数据或动作部分的绑定延迟到子类（晚绑定数据）。

针对上述代码，利用模板方法做出的改进如下：

库代码 Library.cpp：

//程序库开发人员
class Library{
public:
	// 稳定 template method
	// 稳定的代码写成实体的(比如Run()，step1,step3,step5)，不稳定的写成虚的(如step2和step4)
	// 所有的设计模式都需要有一个稳定点,设计模式就是把稳定和不稳定的隔离出来
    void Run(){
        
        Step1();

        if (Step2()) { //支持变化 ==> 虚函数的多态调用
            Step3(); 
        }

        for (int i = 0; i < 4; i++){
            Step4(); //支持变化 ==> 虚函数的多态调用
        }

        Step5();

    }
	virtual ~Library(){ }

protected:
	void Step1() { //稳定
        //.....
    }
	void Step3() {//稳定
        //.....
    }
	void Step5() { //稳定
		//.....
	}

	// 变化的部分需进行晚绑定:本类不对这个函数进行实现，交给子类去重写
	virtual bool Step2() = 0;
    virtual void Step4() =0; 
};

应用程序代码Application.cpp：

//应用程序开发人员
class Application : public Library {
protected:
	virtual bool Step2(){
		//... 子类重写实现
    }

    virtual void Step4() {
		//... 子类重写实现
    }
};

int main()
{
	    Library* pLib=new Application();
	    lib->Run();
		delete pLib;
	}
}

总结：当程序中一个流程是固定的时，就可以将这个流程写成一个函数模板，并利用继承与虚函数，将变化的动作和不变化的动作分离开来，变化的动作延迟到子类（运行时）进行绑定。其类图如下：