虚函数效率和“final”关键字

Question

考虑一个程序，它有一个类 Foo，其中包含一个函数 Foo::fn，声明如下：

virtual void fn();

还有一个名为Bar 的Foo 的子类。将像这样声明Bar::fn：

virtual void fn() override final;

导致在Bar 或Bar 的子类中调用fn 更有效，还是它只会阻止Bar 的子类覆盖fn？如果使用final 使调用更高效，那么定义Bar::fn 使其功能与Foo::fn 完全相同的最简单、最有效的方法是什么？

Answer 1

如果fn 在Bar 中定义为final，则编译器可以通过指针或对Bar 的引用静态地调度对fn 的调用，因为它知道Bar::fn 是最终的覆盖器。比如这个程序片段：

struct Foo {
  virtual void fn();
};

struct Bar : Foo {
  void fn() final override;
};

void with_foo(Foo& o) { o.fn(); }
void with_bar(Bar& o) { o.fn(); }

编译为 (See gcc.godbolt.org for details)：

with_foo(Foo&):
    subq    $8, %rsp
    movq    (%rdi), %rax
    call    *(%rax)
    addq    $8, %rsp
    ret

with_bar(Bar&):
    subq    $8, %rsp
    call    Bar::fn()
    addq    $8, %rsp
    ret

with_foo 中的调用通过 vtable 动态调度（call *(%rax) 是间接调用），但with_bar 中的调用静态调度到Bar::fn()。

使Bar::fn 成为Foo::fn 的最终覆盖而不改变行为的最简单方法是将其定义为静态调用Foo::fn：

struct Bar : Foo {
  void fn() final override { Foo::fn(); }
};

Answer 2

我从来不关心 vtable 的大小。它通常相对较小，每个类声明只有一个。更麻烦的是类实例中占用的额外空间，因为除了单例之外，类实例通常很多。因此，以某种方式将额外的元素添加到类中肯定会影响内存量。如果 vtable 太大真的让您感到困扰，那么请进行一些重新设计，以便没有那么多不同的虚拟成员函数（可能将类层次结构分成几个类）或更少的派生类。但实际上，即使你有数百个类，每个类都有一百个虚拟成员函数，它仍然相对较小——200 个类和 100 个成员将占用每个条目 20000 * 8 字节 [64 位架构] -> 160KB。肯定有 20000 个函数 [是的，理论上，每个派生类只需要一个新函数就需要一个新的 vtable，但这是一个相当愚蠢的设计，实际上不太可能]

final 关键字的目的是确保您不会从它进一步派生 - 例如，如果您有一个不应“更改”某些特定功能的基本类层次结构，这很有用。比如说你有：

class user_base
{
    public:
      virtual bool check_password(); {... magical code .. };
      virtual bool is_super_user() = 0;
};

class superuser : public user_base
{
    public:
      virtual bool check_password() final  
        { .... magical code ...
          ... extra checks to ensure no remote login... 
        }
      virtual bool is_super_user() final { return true; }

 };

 class user : public user_base
 {
  public:
      virtual bool is_super_user() final { return false; }
 };

您必须采取一些技巧来确保user_base 不被用作fake_super_user 的基类，当然，这样的设计还有其他大的安全问题，但它给了你一些想法。