7 模板方法模式

，定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法是的子类可以不改变一个算法的结构即可重定义该算法的某些特定的步骤。

 

 

模板方法模式

“模板方法是通过把不变形为搬移到超类，去除子类中重复代码来体现它的优势。”

“既然用了继承，并且肯定这个继承有意义，就应该要成为子类的模板，所有重复的代码都应该要上升到父类去，而不是让每个子类都去重复。”

“我们要完成在某一细节层次一致的一个过程或一些列步骤，但其个别步骤在更详细的层次上的实现可能不同时，我们通常考虑模板方法模式来处理。”

#include <iostream>
#include <string>

 using std::cout;
 using std::endl;
 using std::string;

 //金庸小说考题试卷
 class TestPater
{
public:
    void TestQuestion1()
    {
        cout<<"杨过得到，后来给了郭靖，炼成倚天剑、屠龙刀的玄铁是[]\
            a.球磨铸铁 b.马口铁 c.告诉合金钢 d.碳素纤维"<<endl;
        cout<<"答案："<<Answer1()<<endl<<endl;
    }
    void TestQuestion2()
    {
        cout<<"杨过、程英、陆无双铲除了情花，造成[]\
            a.这种植物不再害人 b.是一种珍稀物种灭绝 c.破坏了那个生物圈的生态平衡 d.造成该地区沙漠化"<<endl;
        cout<<"答案："<<Answer2()<<endl<<endl;
    }
    void TestQuestion3()
    {
        cout<<"蓝凤凰致使华山师徒、桃谷六仙呕吐不止，如果你是大夫，会给他们开什么药[]\
            a.阿司匹林 b.牛黄解毒片 c.氟哌酸 d.让他们喝大量的生牛奶 e.以上全不对"<<endl;
        cout<<"答案："<<Answer3()<<endl<<endl;
    }

    virtual string Answer1()
    {
        return "";
    }
    virtual string Answer2()
    {
        return "";
    }
    virtual string Answer3()
    {
        return "";
    }
};

//学生甲抄的试卷
class TestPaterA : public TestPater
{
public:
    string Answer1()
    {
        return "a";
    }
    string Answer2()
    {
        return "b";
    }
    string Answer3()
    {
        return "c";
    }
};

//学生乙抄的试卷
class TestPaterB : public TestPater
{
public:
    string Answer1()
    {
        return "c";
    }
    string Answer2()
    {
        return "b";
    }
    string Answer3()
    {
        return "a";
    }
};

int main()
{
    cout<<"学生甲抄的试卷："<<endl;
    TestPater* studentA = new TestPaterA();
    studentA->TestQuestion1();
    studentA->TestQuestion2();
    studentA->TestQuestion3();

    cout<<"学生乙抄的试卷："<<endl;
    TestPater* studentB = new TestPaterB();
    studentB->TestQuestion1();
    studentB->TestQuestion2();
    studentB->TestQuestion3();

    return 0;
}

 

#include <iostream>

using std::cout;
using std::endl;

class AbstractClass
{
public:
    void TemplateMethod() //给出了逻辑的骨架，而逻辑的组成是一些抽象操作，它们都推迟到子类实现
    {
        PrimitiveOperation1();
        PrimitiveOperation2();
        cout<<"公共操作"<<endl;
    }
    virtual void PrimitiveOperation1() = 0;
    virtual void PrimitiveOperation2() = 0;
};

class ConcreteClassA : public AbstractClass
{
public:
    void PrimitiveOperation1()
    {
        cout<<"具体类A方法1实现"<<endl;
    }
    void PrimitiveOperation2()
    {
        cout<<"具体类A方法2实现"<<endl;
    }
};

class ConcreteClassB : public AbstractClass
{
public:
    void PrimitiveOperation1()
    {
        cout<<"具体类B方法1实现"<<endl;
    }
    void PrimitiveOperation2()
    {
        cout<<"具体类B方法2实现"<<endl;
    }
};

int main()
{
    AbstractClass* c;

    c = new ConcreteClassA();
    c->TemplateMethod();

    delete c;

    c = new ConcreteClassB();
    c->TemplateMethod();

    return 0;
}