基类可以知道派生类是否重写了虚拟方法吗？

Question

对于C＃存在相同的问题，但不适用于C ++。

class Base
{
    void dispatch()
    {
        if (newStyleHasBeenOverridden())   //how to find this out?
            newStyle(42);
        else
            oldStyle(1, 2);
    }

    virtual void oldStyle(int, int) { throw "Implement me!"; }
    virtual void newStyle(int) { throw "Implement me!"; }
}

class Derived:public Base
{
    void newStyle(int) override
    {
        std::cout<<"Success!";
    }
}

Answer 1

警告 ：此解决方案不是跨平台的，因为它依赖于GCC扩展和某些未定义的行为。

GCC允许语法通过说this->*&ClassName::functionName从this的vtable中获取指向函数的指针。 实际使用它可能不是一个好主意，但是无论如何这是一个演示：

#include <iostream>

class Base {
public:
    void foo() {
        auto base_bar_addr = reinterpret_cast<void*>(&Base::bar);
        auto this_bar_addr = reinterpret_cast<void*>(this->*&Base::bar);
        std::cout << (base_bar_addr == this_bar_addr ? "not overridden" : "overridden") << std::endl;
    }

    virtual void bar() { };
};

class Regular : public Base { };

class Overriding : public Base {
public:
    virtual void bar() { };
};

int main() {
    Regular r;
    r.foo();
    Overriding o;
    o.foo();
}

---

对于后代：

• ICC允许使用该语法，但是它具有不同的含义，与仅说&Base::bar ，因此您始终会认为它没有被覆盖。
• Clang和MSVC完全拒绝该代码。

Answer 2

这是一个设计问题。

但是，为了回答实际问题，有两种方法可以完成此任务而无需重新设计（但实际上，您应该重新设计它）。

一种（可怕的）选择是调用newstyle方法，并捕获未覆盖的异常。

void dispatch() {
    try {
        newStyle(42);
    } catch (const char *) {
        oldStyle(1, 2);
    }
}

如果newStyle已被覆盖，则将调用覆盖。 否则，将抛出基本实现，该调度将捕获，然后回退到oldStyle。 这是对异常的滥用，并且性能会很差。

另一种（稍差一些）的方法是将newStyle的基本实现转发到oldStyle。

void dispatch() {
    newStyle(42);
}

virtual void newStyle(int) { oldStyle(1, 2); }
virtual void oldStyle(int, int) { throw "implement me"; }

这至少朝着更好的设计方向发展。 继承的重点是允许高级代码能够互换使用对象，而不管其专业性如何。 如果调度员必须检查实际的对象类型，则您违反了《里斯科夫替代原理》。 调度应该能够以相同的方式处理所有对象，并且行为上的任何差异都应由重写的方法本身引起（而不是存在重写）。

Answer 3

使事情变得更简单的是， Derived决策由Derived类完成。
抽象Base类基本上只是一个“接口”， Derived类应在其中实现所有 virtual函数。

这个问题听起来也像是XY问题。

我以为这就是你想要的：

class Base // abstract class
{
   virtual void oldStyle(int, int) = 0; // pure virtual functions
   virtual void newStyle(int) = 0;      // needs to be implemented
};

class Derived:public Base
{
   public:
      Derived(bool useNewStyle): _useNewStyle(useNewStyle) {}
      void newStyle(int) { std::cout << "new style"; }
      void oldStyle(int, int) { std::cout << "old style"; }
      void dispatch()
      {
         if (_useNewStyle) {
            newStyle(42);
            return;
         }
         oldStyle(1, 2);
         return;
      }

   private:
      bool _useNewStyle = false;
};

Derived d(true); // use new style
d.dispatch();    // "new style"