override specifier (since C++11)

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

C++ language

 

Classes

General

overview

class/struct types

union types

injected-class-name

Members

data members

static members

the this pointer

nested classes

member templates

bit fields

using-declarations

member functions

member access specifiers

constructors and member initializer lists

default member initializer(C++11)

friend specifier

explicit specifier

converting constructor

Special member functions

default constructor

copy constructor

move constructor(C++11)

copy assignment operator

move assignment operator(C++11)

destructor

Inheritance

base and derived classes

empty base optimization

virtual member functions

pure virtual functions and abstract classes

override(C++11)

final(C++11)

 

Specifies that a virtual function overrides another virtual function.

Syntax

The identifier override, if used, appears immediately after the declarator in the syntax of a member function declaration or a member function definition inside a class definition.

declarator virt-specifier-seq(optional) pure-specifier(optional)	(1)
declarator virt-specifier-seq(optional) function-body	(2)

1) In a member function declaration, override may appear in virt-specifier-seq immediately after the declarator, and before the pure-specifier, if used.

2) In a member function definition inside a class definition, override may appear in virt-specifier-seq immediately after the declarator and just before function-body.

In both cases, virt-specifier-seq, if used, is either override or final, or final override or override final.

Explanation

In a member function declaration or definition, override ensures that the function is virtual and is overriding a virtual function from a base class. The program is ill-formed (a compile-time error is generated) if this is not true.

override is an identifier with a special meaning when used after member function declarators: it's not a reserved keyword otherwise.

Example

Run this code

struct A
{
    virtual void foo();
    void bar();
};
 
struct B : A
{
    void foo() const override; // Error: B::foo does not override A::foo
                               // (signature mismatch)
    void foo() override; // OK: B::foo overrides A::foo
    void bar() override; // Error: A::bar is not virtual
};

See also

• final specifier (since C++11)