模板方法模式：改变算法的架构

Question

我在我的项目中使用模板方法模式，如下所示

class Template
{
public:
void algorithm();
{
    A();
    B();
}
private:
virtual void A()=0;
virtual void B()=0;
}

我有一些子类以不同的方式实现方法 A 和 B。
但现在我需要一个新类 Template2 来实现稍微不同的算法。

class Template2
{
public:
void algorithm();
{
    A();
    B();
    C();
}
private:
virtual void A()=0;
virtual void B()=0;
void C()
{
    //some stuff
    A();
    //some stuff
    B();
}
}

C 在所有子类中都是相同的，所以我没有将其设为虚拟。
现在我基于 Template2 创建了一个新的继承层次结构，但这似乎很愚蠢，因为我必须将每个子类的代码复制并粘贴到这个新层次结构中。
有没有更优雅的方式呢？

编辑
对不起，我没有说清楚。
现在我有两个继承层次结构。
1.一个抽象类Template和一些子类A1,A2,A3,A4...
2.一个抽象类Template2和一些子类B1,B2,B3,B4...
这很好用，但我想知道是否有办法以某种方式合并这两个层次结构，因为 A1 和 B1 具有相同的代码，只是它们分别来自 Template 和 Template2。
解决方案是否是模板方法模式与我无关
bcperth 和 Spotted 的答案都对我有用 :)
非常感谢。

Answer 1

我同意 Spotted 的观点，但您是否考虑过为您的 template 课程添加额外的算法？它仍然是具有多种算法的模板模式。你得到一个更胖的类，但没有代码重复。下面是一个插图。

#include <iostream>

using namespace std;

class Template
{
public:
    void algorithm1()
    {
        A();
        B();
    }

    void algorithm2()
    {
        A();
        B();
        C();
    }

private: void C()
    {
    cout << endl << "start C() ";
    A();
    cout << "middle C() ";
    B();
    cout << "end C()" << endl;
    }

private:
    virtual void A() = 0;
    virtual void B() = 0;
};

class real :public Template {

    void A() { cout << "A(1)  "; }
    void B() { cout << "B(1) "; }
};

int main()
{
    real Real;
    cout << "algorithm1" <<endl;
    Real.algorithm1();
    cout << endl;
    cout << endl << "algorithm2 << endl";
    Real.algorithm2();

    return 0;
}

Answer 2

首先，请原谅我糟糕的 C++ 语法。

我建议你将A() 和B() 与Template 解耦，以便在Template2 中更轻松地重用它们

class Strategy
{
    public:
    virtual void A()=0;
    virtual void B()=0;
}

那么在Template和Template2之间有一个共同的祖先：

class AbstractTemplate
{
    public:
    virtual void algorithm()=0;
}

最后将Template 和Template2 实现为“最终”类（=不需要子类）。

class Template : AbstractTemplate
{
    public:
    Template(Strategy strategy)
    {
        this.strategy = strategy;
    }
    void algorithm()
    {
        strategy.A();
        strategy.B();
    }
    private:
    Strategy strategy;
}

class Template2 : AbstractTemplate
{
    public:
    Template2(Strategy strategy)
    {
        this.strategy = strategy;
    }
    void algorithm()
    {
        strategy.A();
        strategy.B();
        C();
    }
    private:
    Strategy strategy;
    void C()
    {
        //some stuff
        strategy.A();
        //some stuff
        strategy.B();
    }
}

Template 和 Template2 之间的重叠很小（考虑到您不需要子类，我认为没关系）。