Requiring virtual function overrides to use override keyword

C++11 added override to ensure that member functions you write that you intend to override base-class virtual functions actually do (or won't compile).

But in a large object hierarchy, sometimes you could accidentally end up writing a member function that overrides a base-class virtual when you didn't intend it! For instance:

struct A {
    virtual void foo() { }  // because obviously every class has foo().
};

struct B : A { ... };

class C : B {
private:
    void foo() {
        // was intended to be a private function local to C
        // not intended to override A::foo(), but now does
    }
};

Is there some compiler flag/extension that would at least issue a warning on C::foo ? For readability and correctness, I just would like to enforce that all overrides use override .

---

Looks like the GCC 5.1 release added exactly the warning I was looking for:

-Wsuggest-override
Warn about overriding virtual functions that are not marked with the override keyword.

Compiling with -Wsuggest-override -Werror=suggest-override would then enforce that all overrides use override .

---

There are two things you can do.

First, Clang 3.5 and higher have a -Winconsistent-missing-override warning (triggered by -Wall ). This does not quite work for your example, but only if you would add a void foo() override {} to class B and not in class C . What you actually want is -Wmissing-override , to locate all missing override , not just the inconsistently missing ones. That is currently not provided, but you might complain on the Clang mailinglist and they might add it.

Second, you use Howard Hinnant's trick to temporarily add final to the base class member function and recompile. The compiler will then locate all further derived classes that attempt to override the virtual base member function. You can then fix the missing ones. It's a bit more work and requires frequent rechecking when your class hierarchy expands.

---

The problem I see with -Werror=suggest-override is that it does not allow you to write the following:

void f() final {...}

Even though there is an implicit override here. The -Werror=suggest-override does not ignore this (like it should, since the override is redundant in this case)

But it is more complicated than that... If you write

virtual void f() final {...}

It means a completely different thing than

virtual void f() override final {...}

The first case does not need to override anything! The second does.

So I am assuming the GCC check is implemented this way (ie to sometimes accept the redundant override ) in order to get the last case right. But this does not play well eg with clang-tidy, which will correctly remove the override when final is sufficient (but then GCC compilation will fail...)

链接地址: http://www.djcxy.com/p/89622.html

上一篇: 覆盖纯虚函数时使用`override'有什么意义吗？

下一篇: 要求虚拟函数覆盖使用覆盖关键字