如何确定一种方法正在覆盖 C++ 中现有的虚拟方法？

Question

假设我们有一个基类，它有一个虚方法：

class BaseClass
{
    virtual void MethodToOverride() const
    {
        DoSomething();
    }
};

还有一个覆盖该方法的派生类（根据情况我们可以将其再次设为虚拟或不虚拟）：

class DerivedClass : public BaseClass
{
    void MethodToOverride() const
    {
        DoSomethingElse();
    }
}

如果我们犯了错误，例如定义 MethodToOverride 非 const 或使用错误的字符，我们只需定义一个新方法，例如：

void MethodToOverride() {} // I forgot the const 
void MthodToOverride() const {} // I made a typo

所以这编译得很好，但在运行时会导致不需要的行为。

有没有办法将函数定义为对现有函数的显式覆盖，所以如果我定义错误，编译器会警告我？类似的东西（我知道它不存在）：

void MethodToOverride() const overrides BaseClass::MethodToOverride() const {} 

Answer 1

最好的办法是在BaseClass中声明方法是纯虚的。

class BaseClass 
{ 
    virtual void MethodToOverride() const = 0;
};

如果实现类再次被继承（我认为这是一种半好的做法），则无法控制正确的实现。

Answer 2

[[override]] 属性。但是它是C++0x 的一部分。

如果您使用 gcc，请考虑 -Woverloaded-virtual 命令行选项。

Answer 3

C++0x 为此提供了一个属性（请参阅 vitaut 的答案），例如Visual C++ 提供语言扩展。

但在可移植的 C++98 中，您能做的最好的事情是进行健全性检查，即基类提供了一个可访问的成员函数，该函数接受相同的参数，例如 ...

// The following macro is mainly comment-like, but performs such checking as it can.
#define IS_OVERRIDE_OF( memberSpec, args ) \
    suppressUnusedWarning( sizeof( (memberSpec args, 0) ) )

在哪里

template< typename T >
inline void suppressUnusedWarning( T const& ) {}

您在覆盖实现中调用宏，并使用函数的实际参数。

编辑添加调用示例（免责声明：编译器未触及）：

class BaseClass
{
protected:
    virtual void MethodToOverride() const
    {
        DoSomething();
    }
};

class DerivedClass : public BaseClass
{
protected:
    void MethodToOverride() const
    {
        IS_OVERRIDE_OF( BaseClass::MethodToOverride, () );
        DoSomethingElse();
    }
};

在某些情况下使用这种健全性检查可以提高代码的清晰度，并且在某些情况下可以节省您的精力。它有三个成本。 (1) 其他人可能会将其误认为是保证，而不仅仅是信息性评论和部分检查。 (2) 成员函数在基类中不能是私有的，就像在您的示例中那样（尽管这可能是积极的）。 (3) 有些人本能地对任何宏的使用做出消极反应（他们只是记住了一条关于坏的规则而没有理解它）。

干杯，

Answer 4

如果您的基类可能是一个抽象类，那么解决方案是使您想要被覆盖的方法成为纯虚拟的。在这种情况下，如果您尝试实例化派生类，编译器会大喊大叫。请注意，纯虚函数也可以有定义。

例如

class BaseClass
{
    virtual void MethodToOverride() const = 0;
    //let's not forget the destructor should be virtual as well! 
};

inline void BaseClass::MethodToVerride const()
{
    DoSomething();
}
//note that according to the current standard, for some inexplicable reasons the definition
//of a pure virtual function cannot appear 'inline' in the class, only outside

如果你不能让你的基类变得抽象，那么 C++03 几乎没有什么可做的，@vitaut 的答案给出了你对 C++0x 的需求。

你的问题中有一句话让我感到震惊。您说您可以选择是否使该方法进一步虚拟化。好吧，在 C++03 中你不能。如果该方法已被声明为虚拟，则无论您是否明确指定它，它将在整个层次结构中都是虚拟的。例如

class A
{
    virtual void f(){}
} ;
class B: public A
{
   void f(); //same as virtual void f();
};

Answer 5

你可以试试这个：)

#include <iostream>

using namespace std;

class Base
{
    public:
        virtual void YourMethod(int) const = 0;
};

class Intermediate : private Base
{
    public:
        virtual void YourMethod(int i) const
        {
            cout << "Calling from Intermediate : " << i << "\n";
        }
};

class Derived : public Intermediate, private Base
{
    public:
        void YourMethod(int i) const
        {
            //Default implementation
            Intermediate::YourMethod(i);

            cout << "Calling from Derived : " << i << "\n";
        }
};

int main()
{
    Intermediate* pInterface = new Derived;
    pInterface->YourMethod(10);
}

我认为代码不言自明。 Base 确保您使用正确的签名实现函数（作为副作用，即使您可以使用默认行为，您也总是会实现它），而作为接口的Intermediate 确保存在默认实现。但是，您会收到警告:)。