编译器如何确定它正在处理的多态类型[重复]

Question

我有一些代码可以访问派生和基础 ptr，当我打印出地址时，它们是相同的。如果是这种情况，编译器如何知道它所引用的地址是 A 还是 B？

代码如下：

#include <iostream>

class A
{
public:
   A() : val_(0) {
       ptrA = this;
   }

   virtual void set(int val) { val_ = val; }

   virtual void printval() = 0;

   static A* ptrA;

   int val_;
};

class B : public A
{
public:
   B() : A() {
      ptrB = this;
   }

   virtual void printval() { std::cout << A::val_ << std::endl; }

   static B* ptrB;
};

A* A::ptrA = 0;
B* B::ptrB = 0;

int main() {

   A* p = new B();
   p->set(3);
   p->printval();

   std::cout << "A part address=" << A::ptrA << std::endl;
   std::cout << "B part address=" << B::ptrB << std::endl;

   return 0;
}

这是打印输出：

A part address=00501F40
B part address=00501F40

两个地址完全相同。编译器是否也存储了一些额外的信息？

编辑： 是的，我的意思是说程序在运行时是如何知道的。

Answer 1

通过依赖于实现的机制内置的额外信息。当你编译你的程序时，编译器会悄悄地添加它需要记录的所有代码。
对于几乎所有编译器，动态调度都是通过虚拟表和指针实现的。

美食阅读：

What happens in the hardware when I call a virtual function? How many layers of indirection are there? How much overhead is there?

Answer 2

实际上，假设像你这样的“普通”C 实现，B 类的大部分数据是一个结构，而该结构的第一个成员是 A 类的对象。因为 B 和它的 A包含在同一个地方开始，它们具有相同的地址。

因为 B 的开头有一个 A 对象，所以可以将指向 B 对象的指针转换为指向 A 对象的指针，它的行为就像一个 A 对象，因为它是：它是指向 A 的指针数据。

虚函数更复杂。在 A 数据内部，您通常看不到，它是一个指向表的指针。如果该对象真的是一个普通的 A 对象，则该指针将指向一个包含 A 的虚函数地址的表。如果该对象是 B 对象，则该指针指向一个包含虚函数地址的表B 的函数。结果是，如果您有一个指针，其编译时类型似乎是指向 A 的指针，编译器通过在表中查找它们的地址来调用它的函数。如果指向对象的实际类型是 B，则该表提供 B 的虚函数地址。