确保每个派生 class（包括直接派生 class 的派生 classes）实现一个方法的模式是什么？

Question

我有一个基数class和若干代后代（派生classes）：

class Base{
    public:
    virtual void myFunc() = 0;
}
    
class Derived : public Base{
    //This class needs to implement myFunc()
}
    
class Derived2 : public Derived{
    //How to force this class to implement its version of myFunc(), and force it to call Derived::myFunc as well ?
}
    
class Derived3 : public Derived2{
    //.....should implement its own myFunc and call Derived2's mynFunc()...
}
    
class Derived4 : public Derived3{
    //.....should implement its own myFunc and call Derived3's mynFunc()...
}

是否有模式可以保证：

每个派生的class（不管它是基class的直接后代，还是基class后代的后代），实现它的版本myFunc?
每个派生 class 调用其直接父 class myFunc?

编辑：我想到的模式是装饰器模式，但想知道是否有更好的方法或变体。

Answer 1

我提出以下解决方案：

#include <iostream>

template <class BaseClass>
class RequireMyFunc: public BaseClass
{
    public:
    virtual void myFunc() = 0; // declaration to force write implementation
    protected:
    void callBaseClassMyFunc() override
    {
        BaseClass::callBaseClassMyFunc();
        BaseClass::myFunc();
    }
};

class Base{
    public:
    void func()
    {
        callBaseClassMyFunc();
        //myFunc();
    }
    virtual void myFunc(){};
    protected:
        Base(){}
        virtual void callBaseClassMyFunc(){};
};
    
class Derived : public RequireMyFunc<Base>{
    public:
    void myFunc() override
    {
        std::cout << "Derived" << std::endl;
    }
};
    
class Derived2 : public RequireMyFunc<Derived>{
    public:
    void myFunc() override
    {
        std::cout << "Derived2" << std::endl;
    }
};
    
class Derived3 : public RequireMyFunc<Derived2>{
    public:
    void myFunc() override
    {
        std::cout << "Derived3" << std::endl;
    }
};

int main()
{
    Base* d = new Derived();
    d->func();  // prints "Derived" (invokes only Derived::myFunc)
    
    Base* d2 = new Derived2();
    d2->func(); // prints "Derived" and "Derived2", i.e. invokes Derived::myFunc and Derived2::myFunc
    
    Base* d3 = new Derived3();
    d3->func(); // prints "Derived", "Derived2" and "Derived3"
    
    d->myFunc(); // prints "Derived"
    d2->myFunc(); // prints only "Derived2"
    d3->myFunc(); // prints only "Derived3"
    
    // Base* b = new Base(); -- cannot create because of protected constructor
    //b->myFunc(); // prints nothing
}

确保每个派生 class（包括直接派生 class 的派生 classes）实现一个方法的模式是什么？

What is a pattern to ensure that every derived class (including derived classes of the immediate derived class) implement a method?

c++

c++11