Should I always use the override contextual keyword?

Question

I know that the override contextual keyword was introduced to write safer code (by checking for a virtual function with the same signature) but I don't feel good about it, because it seems to be redundant for me to write override every time I want to override a virtual function.

Is it a bad practice to not use override contextual keyword for 99% of cases? Why/when should I have to use it (a compiler warning is not enough when we are hiding a virtual function mistakenly)?

EDIT: In other words; what is the advantage of using the override contextual keyword in C++11 while we always had a compiler warning if we were hiding a virtual function mistakenly in C++03 (without using override contextual keyword)?

Answer 1

The override keyword is totally useful and I would recommend using it all the time.

If you misspell your virtual function it will compile fine but at runtime the program will call the wrong function. It will call the base class function rather than your override.

It can be a really difficult bug to find:

#include <iostream>

class Base
{
public:
    virtual ~Base() {}

    virtual int func()
    {
        // do stuff for bases
        return 3;
    }
};

class Derived
: public Base
{
public:

    virtual int finc() // WHOOPS MISSPELLED, override would prevent this
    {
        // do stuff for deriveds
        return 8;
    }
};

int main()
{
    Base* base = new Derived;

    std::cout << base->func() << std::endl;

    delete base;
}

Answer 2

Annotations are what you call contextual keywords, they serve as clarification, to make sure anyone who reads the code realizes it is a function that overrides a function in a superclass or a interface. The compiler can also give a warning if the originally overridden feature was removed, in which case you might want to think about removing your function as well.

As far as I know, nothing bad happens if you ommit anotations. It's neither right nor wrong. Like you stated correctly already: annotations are introduced to write safer code. However: They won't change your code in any functional way.

If you work as a single programmer on your own project it might not matter wheter you use them or not. It is however good practice to stick to one style (i.e. either you use it, or you don't use it. Anything inbetween like sometimes using it and sometimes not only causes confusion)

If you work in a Team you should discuss the topic with your teammates and decide wheter you all use it or not.

Answer 3

What is the advantage of using override contextual keyword in C++11 while we always had a compiler warning if we were hiding a virtual function mistakenly

Nearly none!?

But: It depends on how much warnings will be accepted by your build rules. If you say, every warning MUST be fixed, you will get the same result UNTIL you are using a compiler which give you the warning.

We have decided to always use override and remove virtual on overriding methods. So the "overhead" is zero and the code is portable in the meaning of "give an error" on misuse.

I personally like this new feature, because it makes the language clearer. If you say this is an override, it will be checked! And if we want to add a new method with different signature, we will NOT get a false positive warning, which is important in your scenario!