> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C++ Final Function
The `final` specifier in C++ is a context-sensitive keyword introduced in C++11 that, when applied to a virtual member function, explicitly prohibits any derived classes from further overriding that function. If a derived class attempts to override a function marked as `final`, the program is ill-formed and the compiler will generate an error.
## Syntax and Placement
The `final` specifier must appear immediately after the function declarator. In a member function declaration, it is placed after the parameter list, `const` or `volatile` qualifiers, reference qualifiers (`&` or `&&`), and `noexcept` specifiers, but before the function body or pure virtual specifier (`= 0`).
```cpp theme={"dark"}
class Base {
public:
// Syntax: virtual return_type function_name() [qualifiers] final;
virtual void execute() const noexcept final;
};
```
## Technical Rules and Mechanics
* **Virtual Requirement:** The `final` specifier can only be applied to member functions that are `virtual`. Applying `final` to a non-virtual member function results in a compilation error.
* **Context-Sensitive Identifier:** `final` is not a globally reserved keyword in C++. It only holds special meaning when used in the specific syntactic position of a class or function declaration. You can still use `final` as a variable or function name elsewhere in the codebase.
* **Inheritance Termination:** Marking a function as `final` does not prevent the class itself from being inherited (unless the class is also marked `final`), but it seals the specific virtual function's implementation at that level of the inheritance hierarchy.
* **Combination with `override`:** It is syntactically valid and common to combine `final` with the `override` specifier. The order of `override` and `final` does not strictly matter to the compiler, but `override final` is the standard convention.
## Code Visualization
The following example demonstrates the mechanics of the `final` specifier within an inheritance chain and the resulting compiler behavior:
```cpp theme={"dark"}
class AbstractBase {
public:
virtual void initialize() = 0;
virtual void process() const;
};
class Intermediate : public AbstractBase {
public:
// Valid: Overrides pure virtual function
void initialize() override;
// Valid: Overrides virtual function and seals it
void process() const override final;
};
class Leaf : public Intermediate {
public:
// Valid: 'initialize' is not final in Intermediate
void initialize() override;
// COMPILE-TIME ERROR: Cannot override a 'final' function
void process() const override;
};
```
## Devirtualization
From a compiler mechanics perspective, marking a function as `final` provides a strict guarantee to the compiler that no further overrides exist. This allows the compiler's optimizer to perform **devirtualization**. When the compiler resolves a call to a `final` function through a pointer or reference of the type where the function is marked `final`, it can bypass the virtual method table (vtable) lookup and emit a direct function call, or inline the function entirely.
Tired of Poor C++ Skills? Fix That With Deep Grasping!
Learn More
