编译后的 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 最终将消耗 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
 };

< strong>步骤#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 指针指向其类的 v 表，就好像它在每个构造函数的 init 列表中添加以下指令一样：

 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 通过 virt2() 覆盖 virt0() 并按原样继承其他项，则 Der 的 v 表可能看起来像这样（假装 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 表的槽 #3 中的函数。它将调用重写为如下内容：

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

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

---

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

Answer 2

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

所以 Base 类的对象应该是

(*base_address) : i
(*base_address + sizeof(int)) ：f

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

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

Answer 3

“编译类”的意思是“编译方法”。

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

因此，C++ 类与一堆普通函数没有太大区别，除了名称修改和构造函数/析构函数中用于设置 vtable 的一些魔法之外。

Answer 4

与读取 C 对象文件的主要区别在于 C++ 方法名称是损坏的。您可以尝试将选项-C|--demangle与objdump一起使用。

Answer 5

尝试一下

g++ -S 类.cpp

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

Answer 6

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

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

然而，编译器的要点是您不需要了解这些东西（除非您正在编写编译器）。