The override Keyword in C++ Explained

The override keyword in C++ is a special specifier that you can add at the end of a member function declaration or definition in a derived class. Its purpose is to clearly state your intent that this function is meant to override a virtual function from one of its base classes.

1// Base class
2class Base {
3public:
4  virtual void DoSomething() { /* ... */ }
5  virtual void AnotherFunc(int x) { /* ... */ }
6  void NonVirtualFunc() { /* ... */ }
7};
8
9// Derived class
10class Derived : public Base {
11public:
12  // Correctly overrides Base::DoSomething
13  void DoSomething() override { /* ... */ } 
14
15  // Also correct
16  virtual void AnotherFunc(int x) override { /* ... */ } 
17
18  // ERROR: NonVirtualFunc is not virtual in Base
19  // void NonVirtualFunc() override {} // Won't compile
20
21  // ERROR: Typo in name, no Base function matches
22  // void DoSomethang() override {} // Won't compile
23
24  // ERROR: Different signature, no Base function matches
25  // void AnotherFunc(float x) override {} // Won't compile
26};

Using override provides two significant benefits:

Compile-Time Safety

This is the primary advantage. The compiler verifies that your function actually overrides a base class virtual function. If it doesn't match any base class virtual function signature precisely (same name, same parameter types, same const/volatile qualification, same ref-qualifiers), the compiler will generate an error.

Without override****: If you make a typo in the function name or its parameters, you might accidentally create a new, unrelated function in the derived class instead of overriding the base class one. Your code will compile, but polymorphism won't work as expected - calls through a base class pointer might call the base version instead of your intended derived version.

1class DerivedOops : public Base {
2public:
3  // TYPO! No override keyword used.
4  // This compiles, but creates a NEW function,
5  // it DOES NOT override Base::DoSomething()!
6  virtual void DoSomethang() { 
7    // ... oops ...
8  }
9};
10
11Base* ptr = new DerivedOops();
12ptr->DoSomething(); // Calls Base::DoSomething(),
13                    // NOT DerivedOops::DoSomethang()!

With override****: If you make the same typo but include override, the compiler immediately tells you something is wrong.

1class DerivedSafe : public Base {
2public:
3  // TYPO! But override keyword IS used.
4  virtual void DoSomethang() override {
5    // ...
6  }
7  // COMPILER ERROR: 'DoSomethang' marked override
8  // but does not override any base class method.
9};

Improved Readability and Maintainability

The override keyword clearly documents the programmer's intention. Anyone reading the code immediately knows that this function is part of a polymorphism hierarchy and is specifically designed to replace a base class implementation. This makes the code easier to understand and safer to modify later.

You should use override whenever you intend for a function in a derived class to override a virtual function from a base class. It's considered modern C++ best practice. While not strictly required for overriding to occur (if the signature matches perfectly), the safety net and clarity it provides are invaluable.

Note that override can only be used on virtual functions in derived classes. Trying to use it on non-virtual functions or on functions in a class with no base classes will result in a compiler error.