Question

我正在开发一个大型软件，该软件高度依赖于调用超级反模式。

基本上，接口定义一个init()虚拟方法，然后在继承该方法的每个类中将其重写。在类上调用init()时，从基类到顶级子类，以及介于两者之间的所有重载的init方法都是级联的。

但是用户必须自己调用其直接父级的init()方法，结果是这样的代码：

class myClass : public Base
{
    virtual void init()
    {
        Parent::Init() // often forgotten, or misplaced by the developer
        // Do some init stuff
    }
}

通常可以使用委托。 Base类在init中有事情要做，在Base中声明为final，并将其部分委托给继承类应重写的onInit()方法。但这并没有像我希望的那样将对所有父类的调用层叠起来。

我首先实现的替代方法是委托方法的一种变体。子类和Base都实现onInit()和init()方法。 init()先调用Parent::init()，然后再调用onInit()，并使用模板元编程和宏自动生成。 onInit()包含特定于类的代码。

# define DELEGATE(T, Parent) \
     void init() override { Parent::init(); T::onInit(); }

struct Base
{
    virtual void init() { Base::onInit(); }
    virtual void onInit() {}
};

struct A : public Base
{
     DELEGATE(A, Base)
     void onInit() override { /* MyCustom code for A */ }
};

struct B : public A
{
     DELEGATE(B, A)
     void onInit() override { /* MyCustom code for B */ }
};

这很好用..除了多重继承变得一团糟之外，即使继承，钻石继承也会导致重复调用的问题。

这让我感到奇怪：我不是唯一一个寻求解决我的问题的设计模式的人，而且stackoverflow社区必须对此有所了解：）

您是否曾经遇到过这样的设计模式？我真的很期待您的想法！

Answer 1

这就是我要保护自己，以免忘记在儿童课堂上压倒一切的方法。这是简单的模板方法设计模式实现：

class Base {
public:
    void init() {
        //base init steps
        childInit();
    }

private:
    virtual void childInit() = 0;
};

class Child : public Base {
private:
    void childInit() override { /*init the child*/}
};

级联调用重写虚拟方法

1 个答案: