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

[edit]Syntax

When applied to a member function, the identifierfinal appears immediately after thedeclarator 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 identifierfinal 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 eitheroverride orfinal, orfinal override oroverride final. In the case(3), the only allowed value ofclass-virt-specifier, if used, isfinal. In the case(4), theclass-prop-specifier-seq, if used, can have any number ofclass 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 thebase-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 aunion definition, in which case it has no effect (other than on the outcome ofstd::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 ofclass,struct andunion
2. a possibly qualifiedidentifier
3. final
4. one of: and{

the third tokenfinal 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 operatorint(){return5;}};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 namevoid 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 specifierint main(){}

[edit]Keywords

final

[edit]Example

struct Base{virtualvoid foo();}; struct A: Base{void foo() final;// Base::foo is overridden and A::foo is the final overridevoid 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
• Русский
• 中文