final

指定某个虚函数不能在派生类中被覆盖，或者某个类不能被派生。
在继承关系中“中途”终止派生类的重载

override

指定一个虚函数覆盖另一个虚函数。
避免重载函数名拼写错误，函数原型不匹配，重写了非虚函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <iostream>
using namespace std;

class Base {
    virtual void Turing() = 0;
    virtual void Daaaaa() = 0;
    virtual void Va(int g) = 0;
    virtual void Z() const;
    virtual void Play() = 0;
    void Print();
};

class DerivedMid : public Base {
    void D();
    void Play() final;
};

class DerivedTop : public DerivedMid {
    void Turing() override;
    //void Play() override; // error: DerivedMid 阻止派生类重载 Play()
    //void Daaaa() override; // error: 函数名错误
    //void Va(double d) override; // 
    //void Z() override;
    //void Print() override;
};

struct Base {
    virtual void foo();
};
 
struct A : Base {
    void foo() final; // Base::foo 被覆盖而 A::foo 是最终覆盖函数
    void bar() final; // 错误：bar 非虚，因此它不能是 final 的
};
 
struct B final : A { // struct B 为 final
    void foo() override; // 错误：foo 不能被覆盖，因为它在 A 中是 final 的
};
 
struct C : B{}; // 错误：B 是 final 的

struct A {
    virtual void foo();
    void bar();
};
 
struct B : A {
    void foo() const override; // 错误：B::foo 不覆盖 A::foo
                               // （签名不匹配）
    void foo() override; // OK：B::foo 覆盖 A::foo
    void bar() override; // 错误：A::bar 非虚
};


int main()
{
    return 0;
}