final 是否意味着覆盖？

Question

据我了解，override 关键字表明给定声明实现了基本 virtual 方法，如果找不到匹配的基本方法，编译应该会失败。

我对@9​​87654324@ 关键字的理解是它告诉编译器任何类都不能覆盖这个virtual 函数。

那么override final 是多余的吗？ It seems to compile fine。 override final 传达了哪些final 没有传达的信息？这种组合的用例是什么？

Answer 1

final 不需要函数首先覆盖任何内容。它的效果在[class.virtual]/4中定义为

如果某个类 B 中的虚函数 f 被标记为 virt-specifier final 和一个类 D 派生自 B 一个函数 D::f 覆盖B::f，程序格式错误。

就是这样。现在override final 只是意味着
„此函数会覆盖一个基类 (override)，并且不能被其自身覆盖 (final)。“
final 本身会施加较弱的要求。 override 和 final 具有独立的行为。

---

请注意，final 只能用于虚函数 - [class.mem]/8

virt-specifier-seq 应该只出现在 a 的声明中 虚拟成员函数 (10.3)。

因此声明

void foo() final;

实际上与

相同

virtual void foo() final override;

由于两者都需要foo 覆盖某些东西 - 第二个声明使用override，第一个声明当且仅当foo 是隐式虚拟时才有效，即当foo 被覆盖时基类中称为foo 的虚函数，它使派生类中的foo 自动为虚函数。 因此，override 在出现final 而不是virtual 的声明中是多余的。
不过，后一种声明更清楚地表达了意图，绝对应该首选。

Answer 2

final 并不一定意味着该函数被覆盖。在继承层次结构中的 first 声明中将虚函数声明为 final 是完全有效的（如果其价值有些可疑）。

我能想到创建一个虚拟且立即终止的函数的一个原因是，如果您想防止派生类赋予相同的名称和参数不同的含义。

Answer 3

（如果你赶时间，请跳到最后看结论。）

override 和 final 都只能出现在虚函数的声明中。并且这两个关键字可以在同一个函数声明中使用，但是否有用要视情况而定。

以如下代码为例：

#include <iostream>
using std::cout; using std::endl;

struct B {
  virtual void f1() { cout << "B::f1() "; }
  virtual void f2() { cout << "B::f2() "; }
  virtual void f3() { cout << "B::f3() "; }
  virtual void f6() final { cout << "B::f6() "; }
  void f7() { cout << "B::f7() "; }
  void f8() { cout << "B::f8() "; }
  void f9() { cout << "B::f9() "; }
};

struct D : B {
  void f1() override { cout << "D::f1() "; }
  void f2() final { cout << "D::f2() "; }
  void f3() override final { cout << "D::f3() "; }  // need not have override
  // should have override, otherwise add new virtual function
  virtual void f4() final { cout << "D::f4() "; }
  //virtual void f5() override final;  // Error, no virtual function in base class
  //void f6(); // Error, override a final virtual function
  void f7() { cout << "D::f7() "; }
  virtual void f8() { cout << "D::f8() "; }
  //void f9() override;  // Error, override a nonvirtual function 
};

int main() {
  B b; D d;
  B *bp = &b, *bd = &d; D *dp = &d;
  bp->f1(); bp->f2(); bp->f3(); bp->f6(); bp->f7(); bp->f8(); bp->f9(); cout << endl;
  bd->f1(); bd->f2(); bd->f3(); bd->f6(); bd->f7(); bd->f8(); bd->f9(); cout << endl;
  dp->f1(); dp->f2(); dp->f3(); dp->f6(); dp->f7(); dp->f8(); dp->f9(); cout << endl;
  return 0;
}

输出是

B::f1() B::f2() B::f3() B::f6() B::f7() B::f8() B::f9()
D::f1() D::f2() D::f3() B::f6() B::f7() B::f8() B::f9()
D::f1() D::f2() D::f3() B::f6() D::f7() D::f8() B::f9()

1. 比较 f1() 和 f6()。我们知道override 和final 在语义上是独立的。

   • override 表示该函数正在覆盖其基类中的虚函数。请参阅f1() 和f3()。
   • final 表示该函数不能被其派生类覆盖。 （但函数本身不需要覆盖基类虚函数。）参见f6() 和f4()。

2. 比较 f2() 和 f3()。我们知道，如果一个成员函数被声明为没有virtual 和final，这意味着它已经覆盖了基类中的一个虚函数。在这种情况下，关键字override 是多余的。

3. 比较 f4() 和 f5()。我们知道，如果一个成员函数是用virtual声明的，并且如果它不是继承层次结构中的first虚函数，那么我们应该使用override来指定覆盖关系。否则，我们可能会不小心在派生类中添加新的虚函数。

4. 比较 f1() 和 f7()。我们知道任何成员函数，而不仅仅是虚拟函数，都可以在派生类中被覆盖。 virtual 指定的是多态性，这意味着关于运行哪个函数的决定被延迟到运行时而不是编译时。 （在实践中应该避免这种情况。）

5. 比较 f7() 和 f8()。我们知道我们甚至可以覆盖一个基类函数并使其成为一个新的虚拟函数。 （这意味着从D 派生的类的任何成员函数f8() 都是虚拟的。）（这在实践中也应该避免。）

6. 比较 f7() 和 f9()。我们知道override可以帮助我们在派生类中重写虚函数而忘记在基类中添加关键字virtual时发现错误。

总结，我个人认为的最佳做法是：

• 仅在基类中第一个虚函数的声明中使用virtual；
• 始终使用override 指定派生类中的重写虚函数，除非还指定了final。

Answer 4

以下代码（带有final 说明符）编译。但是当final 被替换为override final 时编译会失败。因此override final 比final 传达更多信息（并阻止编译）。

class Base
{
public:
    virtual ~Base() {}
};

class Derived : public Base
{
public:
    virtual void foo() final
    {
        std::cout << "in Derived foo\n";
    }
};

基本上，override final 表示此方法不能在任何派生类中被覆盖并且此方法会覆盖基类中的虚拟方法。 final 单独没有指定基类覆盖部分。

Answer 5

没有final 不一定暗示override。实际上，您可以声明一个 virtual 函数，然后立即声明 final see here。 final 关键字只是声明没有派生的class 可以创建此函数的覆盖。

override 关键字很重要，因为它强制您确实在覆盖一个虚函数（而不是声明一个新的不相关的函数）。见this post regarding override

长话短说，它们各自都有自己的特定目的，通常两者都使用是正确的。