# final specifier (since C++11)

From cppreference.com
< cpp‎ | language

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

### 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, the identifier `final` appears at the beginning of the class definition, immediately after the name of the class.

declarator virt-specifier-seq(optional) pure-specifier(optional) | (1) |
declarator virt-specifier-seq(optional) function-body | (2) |
class-key attr(optional) class-head-name class-virt-specifier(optional) base-clause(optional) | (3) |

1) In a member function declaration, `final` 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, `final` may appear in virt-specifier-seq immediately after the declarator and just before function-body.
3) In a class definition, `final` may appear as class-virt-specifier immediately after the name of the class, just before the colon that begins the base-clause, if used.

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`

### Explanation

When used in a virtual function declaration or definition, `final` 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 (a compile-time error is generated) otherwise. `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 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.

### Example

Run this code

    struct Base
    {
        virtual void foo();
    };

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

    struct B final : A // struct B is final
    {
        void foo() override; // Error: foo cannot be overridden as it's final in A
    };

    struct C : B // Error: B is final
    {
    };

### See also

- override specifier (since C++11)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/language/final&oldid=97961"