如何确定编译器对虚拟函数使用早期绑定还是晚期绑定？

Question

我有以下代码：

class Pet {
public:
  virtual string speak() const { return ""; }
};

class Dog : public Pet {
public:
  string speak() const { return "Bark!"; }
};

int main() {
  Dog ralph;
  Pet* p1 = &ralph;
  Pet& p2 = ralph;
  Pet p3;

  // Late binding for both:
  cout << "p1->speak() = " << p1->speak() <<endl;
  cout << "p2.speak() = " << p2.speak() << endl;

  // Early binding (probably):
  cout << "p3.speak() = " << p3.speak() << endl;
}

我被要求确定编译器是否对最终函数调用使用早期或晚期绑定。我在网上搜索过但没有找到任何可以帮助我的东西。有人可以告诉我如何执行这项任务吗？

Answer 1

您可以查看反汇编，看看它是否看起来是通过 vtable 重定向的。

线索是它是直接调用函数的地址（早期绑定）还是调用计算的地址（后期绑定）。另一种可能性是该函数是内联的，您可以将其视为早期绑定。

当然，该标准没有规定实现细节，可能还有其他可能性，但这涵盖了“正常”实现。

Answer 2

你总是可以使用 hack :D

//...
Pet p3;
memset(&p3, 0, sizeof(p3));
//...

如果编译器确实使用 vtbl 指针，猜猜会发生什么:>

p3.speak()  // here

Answer 3

查看生成的代码。例如，在 Visual Studio 中，您可以设置断点，然后右键单击并选择“转到反汇编”。

Answer 4

它使用早期绑定。您有一个 P3 类型的对象。虽然它是具有虚函数定义的基类，但类型是具体的并且在编译时已知，因此不必考虑虚函数映射到派生类。

这与在 Pet 构造函数中调用 talk() 非常相似 - 即使在创建派生对象时，当基类构造函数执行时，对象的类型是基类的类型，因此该函数不会使用 v 表，它将调用基本类型的版本。

基本上，早期绑定是编译时绑定，后期绑定是运行时绑定。运行时绑定仅用于编译器在编译时没有足够的类型信息来解析调用的情况。

Answer 5

事实上，编译器没有义务特别使用其中任何一个，只是为了确保调用正确的函数。在本例中，您的对象属于具体类型 Pet，因此只要调用 Pet::speak，编译器就会“做正确的事情”。

现在，鉴于编译器可以静态地查看对象的类型，我怀疑大多数编译器都会优化虚拟调用，但并不要求它们这样做。

如果您想知道您的特定编译器正在做什么，唯一的方法是查阅其文档、源代码或生成的反汇编代码。

Answer 6

我只是想到了一种在运行时判断的方法，无需猜测。您可以简单地用 0 覆盖多态类的 vptr，然后查看该方法是否被调用或者是否出现分段错误。这是我在示例中得到的结果：

Concrete: Base
Concrete: Derived
Pointer: Base
Pointer: Derived
DELETING VPTR!
Concrete: Base
Concrete: Derived
Segmentation fault

其中 Concrete: T 表示通过具体类型调用 T 的虚拟成员函数成功。类似地，Pointer: T表示通过Base指针调用T的成员函数成功。

---

作为参考，这是我的测试程序：

#include <iostream>
#include <string.h>

struct Base {
  unsigned x;
  Base() : x(0xEFBEADDEu) {
  }
  virtual void foo() const {
    std::cout << "Base" << std::endl;
  }
};

struct Derived : Base {
  unsigned y;
  Derived() : Base(), y(0xEFCDAB89u) {
  }
  void foo() const {
    std::cout << "Derived" << std::endl;
  }
};

template <typename T>
void dump(T* p) {
  for (unsigned i = 0; i < sizeof(T); i++) {
    std::cout << std::hex << (unsigned)(reinterpret_cast<unsigned char*>(p)[i]);
  }
  std::cout << std::endl;
}

void callfoo(Base* b) {
  b->foo();
}

int main() {
  Base b;
  Derived d;
  dump(&b);
  dump(&d);
  std::cout << "Concrete: ";
  b.foo();
  std::cout << "Concrete: ";
  d.foo();
  std::cout << "Pointer: ";
  callfoo(&b);
  std::cout << "Pointer: ";
  callfoo(&d);
  std::cout << "DELETING VPTR!" << std::endl;
  memset(&b,0,6);
  memset(&d,0,6);
  std::cout << "Concrete: ";
  b.foo();
  std::cout << "Concrete: ";
  d.foo();
  std::cout << "Pointer: ";
  callfoo(&b);
  std::cout << "Pointer: ";
  callfoo(&d);
  return 0;
}