编译后的 C++ 类是什么样的？

Question

有了汇编指令和 C 程序的一些背景知识，我可以想象编译后的函数的样子，但有趣的是我从来没有仔细考虑过编译后的 C++ 类的样子。

bash$ cat class.cpp
#include<iostream>
class Base
{
  int i;
  float f;
};

bash$ g++ -c class.cpp

我跑了：

bash$objdump -d class.o
bash$readelf -a class.o

但我得到的东西我很难理解。

谁能给我解释一下或建议一些好的起点。

Answer 1

这些类（或多或少）构造为常规结构。这些方法（或多或少......）转换为第一个参数是“this”的函数。对类变量的引用是作为“this”的偏移量完成的。

至于继承，让我们引用 C++ FAQ LITE 的内容，这里是 http://www.parashift.com/c++-faq-lite/virtual-functions.html#faq-20.4 的镜像。本章展示了如何在真实硬件中调用虚函数（编译在机器码中做了什么。

---

让我们举个例子。假设 Base 类有 5 个虚函数：virt0() 到 virt4()。

 // Your original C++ source code
 class Base {
 public:
   virtual arbitrary_return_type virt0(...arbitrary params...);
   virtual arbitrary_return_type virt1(...arbitrary params...);
   virtual arbitrary_return_type virt2(...arbitrary params...);
   virtual arbitrary_return_type virt3(...arbitrary params...);
   virtual arbitrary_return_type virt4(...arbitrary params...);
   ...
 };

第 1 步：编译器构建一个包含 5 个函数指针的静态表，将该表埋入静态内存中的某个位置。许多（不是全部）编译器在编译定义 Base 的第一个非内联虚函数的 .cpp 时定义此表。我们称该表为 v-table；假设它的技术名称是Base::__vtable。如果一个函数指针适合目标硬件平台上的一个机器字，Base::__vtable 最终将消耗 5 个隐藏字的内存。不是每个实例 5 个，不是每个函数 5 个；只是 5. 它可能看起来像下面的伪代码：

 // Pseudo-code (not C++, not C) for a static table defined within file Base.cpp

 // Pretend FunctionPtr is a generic pointer to a generic member function
 // (Remember: this is pseudo-code, not C++ code)
 FunctionPtr Base::__vtable[5] = {
   &Base::virt0, &Base::virt1, &Base::virt2, &Base::virt3, &Base::virt4
 };

第 2 步：编译器向 Base 类的每个对象添加一个隐藏指针（通常也是一个机器字）。这称为 v 指针。把这个隐藏的指针想象成一个隐藏的数据成员，就好像编译器把你的类重写成这样：

 // Your original C++ source code
 class Base {
 public:
   ...
   FunctionPtr* __vptr;  ← supplied by the compiler, hidden from the programmer
   ...
 };

步骤#3：编译器在每个构造函数中初始化this->__vptr。这个想法是让每个对象的 v-pointer 指向其类的 v-table，就好像它在每个构造函数的 init-list 中添加了以下指令：

 Base::Base(...arbitrary params...)
   : __vptr(&Base::__vtable[0])  ← supplied by the compiler, hidden from the programmer
   ...
 {
   ...
 }

现在让我们创建一个派生类。假设您的 C++ 代码定义了继承自类 Base 的类 Der。编译器重复步骤#1 和#3（但不是#2）。在步骤 #1 中，编译器创建一个隐藏的 v 表，保留与 Base::__vtable 中相同的函数指针，但替换与覆盖对应的那些插槽。例如，如果 Der 覆盖 virt0() 到 virt2() 并按原样继承其他的，则 Der 的 v-table 可能看起来像这样（假设 Der 没有添加任何新虚拟）：

 // Pseudo-code (not C++, not C) for a static table defined within file Der.cpp

 // Pretend FunctionPtr is a generic pointer to a generic member function
 // (Remember: this is pseudo-code, not C++ code)
 FunctionPtr Der::__vtable[5] = {
   &Der::virt0, &Der::virt1, &Der::virt2, &Base::virt3, &Base::virt4
 };                                        ^^^^----------^^^^---inherited as-is

在第 3 步中，编译器在 Der 的每个构造函数的开头添加了一个类似的指针赋值。这个想法是改变每个 Der 对象的 v 指针，使其指向其类的 v 表。 （这不是第二个 v 指针；它与基类 Base 中定义的 v 指针相同；请记住，编译器不会在 Der 类中重复步骤 #2。）

最后，让我们看看编译器如何实现对虚函数的调用。您的代码可能如下所示：

 // Your original C++ code
 void mycode(Base* p)
 {
   p->virt3();
 }

编译器不知道这是否会调用Base::virt3() 或Der::virt3() 或者可能是另一个甚至还不存在的派生类的virt3() 方法。它只知道您正在调用virt3()，这恰好是 v-table 的 slot #3 中的函数。它将调用重写为如下内容：

 // Pseudo-code that the compiler generates from your C++

 void mycode(Base* p)
 {
   p->__vptr[3](p);
 } 

---

我强烈建议每位 C++ 开发人员阅读常见问题解答。这可能需要几个星期（因为它很难阅读而且很长），但它会教你很多关于 C++ 的知识以及可以用它做什么。

Answer 2

就像一个 C 结构和一组带有一个附加参数的函数，该参数是一个指向该结构的指针。

遵循编译器所做的最简单的方法可能是在不进行优化的情况下构建，然后将代码加载到调试器中并以混合源/汇编器模式逐步执行。

但是，编译器的重点是您不需要知道这些东西（除非您正在编写编译器）。

Answer 3

与读取 C 对象文件的主要区别在于 C++ 方法名称为 mangled。您可以尝试使用选项-C|--demangle 和objdump。

Answer 4

“已编译的类”表示“已编译的方法”。

方法是带有额外参数的普通函数，通常放在寄存器中（我相信大多数情况下是 %ecx，对于大多数必须使用 __thiscall 约定生成 COM 对象的 Windows 编译器来说至少是这样）。

所以 C++ 类与一堆普通函数并没有太大的不同，除了名称修改和构造函数/析构函数中用于设置 vtables 的一些魔法。

Answer 5

试试

g++ -S 类.cpp

这将为您提供一个汇编文件“class.s”（文本文件），您可以使用文本编辑器阅读该文件。 但是，您的代码不执行任何操作（声明一个类不会自行生成代码），因此您在程序集文件中不会有太多内容。

Answer 6

好的。编译类没有什么特别之处。编译的类甚至不存在。什么是对象，它们是平坦的内存块，字段之间可能有填充？以及代码中某处的独立成员函数，它们将指向对象的指针作为第一个参数。

所以 Base 类的对象应该是某物

(*base_address) : 我 (*base_address + sizeof(int)) : f

字段之间可以有填充吗？但这是特定于硬件的。基于处理器内存模型。

也...在调试版本中，可以在调试符号中捕获类描述。但这是特定于编译器的。您应该搜索一个为您的编译器转储调试符号的程序。