The override keyword was introduced in C++11 to help the compiler verify that a derived class function is actually overriding a virtual function from the base class.

Without override

class Animal {
public:
    virtual void sound() {
        std::cout << "Animal sound\n";
    }
};

class Dog : public Animal {
public:
    void soud() {      // Typo! Missing 'n'
        std::cout << "Bark\n";
    }
};

The compiler does not report an error.

Now:

Animal* a = new Dog();
a->sound();

Output:

Animal sound

Because Dog::soud() is a completely new function, not an override.

With override

class Dog : public Animal {
public:
    void soud() override {   // Typo
        std::cout << "Bark\n";
    }
};

Compiler error:

error: 'Dog::soud()' marked 'override' but does not override

The compiler immediately catches the mistake.

Correct Usage

class Animal {
public:
    virtual void sound() {
        std::cout << "Animal sound\n";
    }
};

class Dog : public Animal {
public:
    void sound() override {
        std::cout << "Bark\n";
    }
};

Now the compiler confirms that:

  • Animal has a virtual function named sound()
  • Dog::sound() has the correct signature
  • It truly overrides the base implementation

Another Common Error It Catches

Suppose the base class has:

virtual void sound(int volume);

But the derived class writes:

void sound() override;

Compiler error:

error: function marked override but does not override

because the parameter list is different.