c++11 关键字 final 使用

写在最前。。。

请支持原创~~ 

1. 功能

• 用以指定一个 virtual function 不能被派生类重写；
• 或者指定一个 class 不能被继承；

2. 语法

对于类中成员函数有两种情况：

• 只声明时，final 紧跟参数的右括号，如果是纯虚函数，final 会出现在 = 0 之前；
• 类中定义时，final 在 函数体之前；

对于类定义，final 紧跟类名；

从c++14 开始，会引入一个 is_final 的判断，确认一个 class 是否被定义为 final，通过使用：

std::is_final<A>::value

来判断 class A 是否为 final。

3. 举例

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()
{
}

final 只是一个标识，在使用成员函数和类定义时有特殊的意义。而在其他情况下可以作为一个对象名、函数名、类名使用。

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

注意这里的几个注意点：

• A 类中 foo() 继承自 Base 类，并把自身定义为 final，即后续继承A 的子类无法再重写 foo()；
• A 类中 bar() 使用了final，但 final 是用在 virtual 的成员函数；
• B 类想重写 foo()，是不允许的，因为在A类中已经声明为 final；
• B 类定义的时候已经被声明为 final，所以无法再被其他类继承，即B 类不会有子类；

4. 原文摘录

Specifies that a virtual function cannot be overridden in a derived class or that a class cannot be derived from.
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.
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
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.