• Log in

Specifies that a virtual function cannot be overridden in a derived class, or that a class cannot be derived from.

[edit] Syntax

When applied to a member function, the identifier final appears immediately after the declarator in the syntax of a member function declaration or a member function definition inside a class definition.

When applied to a class (including struct and union), the identifier final appears at the beginning of the class definition, immediately after the name of the class, and cannot appear in a class declaration.

In the cases (1,2), virt-specifier-seq, if used, is either override or final, or final override or override final. In the case (3), the only allowed value of class-virt-specifier, if used, is final. In the case (4), the class-prop-specifier-seq, if used, can have any number of class property specifiers (since C++26), but each can appear at most once.

[edit] Explanation

When used in a virtual function declaration or definition, final specifier ensures that the function is virtual and specifies that it may not be overridden by derived classes. The program is ill-formed (a compile-time error is generated) otherwise.

When used in a class definition, final specifies that this class may not appear in the base-specifier-list of another class definition (in other words, cannot be derived from). The program is ill-formed otherwise (a compile-time error is generated). final can also be used with a union definition, in which case it has no effect (other than on the outcome of std::is_final )(since C++14), since unions cannot be derived from.

final is an identifier with a special meaning when used in a member function declaration or class head. In other contexts, it is not reserved and may be used to name objects and functions.

[edit] Note

In a sequence of the following tokens:

1. one of class, struct and union
2. a possibly qualified identifier
3. final
4. one of : and {

the third token final in the sequence is always considered as a specifier instead of an identifier.

struct A;
struct A final {}; // OK, definition of struct A,
 // not value-initialization of variable final
 
struct X
{
 struct C { constexpr operator int() { return 5; } };
 struct B final : C{}; // OK, definition of nested class B,
 // not declaration of a bit-field member final
};
 
// Abnormal final usage.
 
struct final final // OK, definition of a struct named `final` from which
{ // you cannot inherit
};
 
// struct final final {}; // Error: redefinition of `struct final`, NOT a
 // definition of a variable `final` using an elaborated
 // type specifier `struct final` followed by an
 // aggregate initialization
 
// struct override : final {}; // Error: cannot derive from final base type;
 // `override` in given context is a normal name
void foo()
{
 [[maybe_unused]]
 final final; // OK, declaration of a variable named `final` of type
 // `struct final` 
}
 
struct final final; // OK, declaration of a variable named `final` of type
 // `struct final` using an elaborated type specifier
int main()
{
}

[edit] Keywords

final

[edit] Example

struct Base
{
 virtual void foo();
};
 
struct A : Base
{
 void foo() final; // Base::foo is overridden and A::foo is the final override
 void bar() final; // Error: bar cannot be final as it is non-virtual
};
 
struct B final : A // struct B is final
{
 void foo() override; // Error: foo cannot be overridden as it is final in A
};
 
struct C : B {}; // Error: B is final

main.cpp:9:10: error: 'void A::bar()' marked 'final', but is not virtual
 9 | void bar() final; // Error: bar cannot be final as it is non-virtual
 | ^~~
main.cpp:14:10: error: virtual function 'virtual void B::foo()' overriding final function
 14 | void foo() override; // Error: foo cannot be overridden as it is final in A
 | ^~~
main.cpp:8:10: note: overridden function is 'virtual void A::foo()'
 8 | void foo() final; // Base::foo is overridden and A::foo is the final override
 | ^~~
main.cpp:17:8: error: cannot derive from 'final' base 'B' in derived type 'C'
 17 | struct C : B // Error: B is final
 |

[edit] References

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] See also

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文