C++对象模型：内存布局、对齐规则与Empty Base Class Optimization（EBCO）

大家好，今天我们深入探讨C++对象模型的核心概念：内存布局、对齐规则以及Empty Base Class Optimization (EBCO)。理解这些概念对于编写高效、可预测的C++代码至关重要。

1. C++对象模型概览

C++对象模型定义了对象在内存中的组织方式。这不仅仅是简单的数据堆砌，还包括虚函数表指针 (vptr) 的存在、继承关系的处理、以及为了性能而进行的内存对齐。掌握这些细节有助于我们理解对象的大小、成员的访问速度，以及多态的底层实现。

2. 基本数据类型的内存布局

C++的基本数据类型（如 int, float, char, double 等）在内存中占据连续的字节。它们的大小是编译器和平台相关的，但通常遵循一定的规范。可以使用 sizeof 运算符来确定特定数据类型的大小。

#include <iostream>

int main() {
  std::cout << "Size of int: " << sizeof(int) << " bytes" << std::endl;
  std::cout << "Size of float: " << sizeof(float) << " bytes" << std::endl;
  std::cout << "Size of char: " << sizeof(char) << " bytes" << std::endl;
  std::cout << "Size of double: " << sizeof(double) << " bytes" << std::endl;
  std::cout << "Size of bool: " << sizeof(bool) << " bytes" << std::endl;
  return 0;
}

输出结果取决于编译器和平台，但通常是：

Size of int: 4 bytes
Size of float: 4 bytes
Size of char: 1 bytes
Size of double: 8 bytes
Size of bool: 1 bytes

3. 结构体和类的内存布局

结构体和类是将多个数据成员组合在一起的方式。它们的内存布局遵循以下原则：

成员按照声明的顺序排列。 这意味着第一个声明的成员位于内存中的较低地址，依此类推。
内存对齐。 为了提高访问效率，编译器可能会在成员之间插入填充字节，以确保成员的起始地址是其大小的倍数。
访问控制（public, private, protected）不影响内存布局。 这些关键字只影响访问权限，不会改变成员在内存中的顺序或位置。

#include <iostream>

struct MyStruct {
  char a;
  int b;
  short c;
};

int main() {
  std::cout << "Size of MyStruct: " << sizeof(MyStruct) << " bytes" << std::endl;
  return 0;
}

在这个例子中，sizeof(MyStruct) 的结果可能不是 1 + 4 + 2 = 7 字节，而是 8 字节。这是因为 int b 需要对齐到 4 字节的边界，所以在 char a 后面可能会插入 3 个填充字节。 short c 也可能需要对齐，取决于编译器和平台。

4. 内存对齐规则

内存对齐是一种优化技术，旨在确保CPU能够高效地访问内存中的数据。大多数 CPU 在访问对齐的数据时速度更快。如果数据没有对齐，CPU可能需要执行多次内存访问才能读取或写入数据，这会降低性能。

对齐规则通常如下：

基本类型： 每个基本类型都有其自身的对齐要求。例如，int 通常需要对齐到 4 字节的边界，double 通常需要对齐到 8 字节的边界。
结构体/类： 结构体或类的对齐要求是其最大成员的对齐要求。
数组： 数组的对齐要求与其元素类型的对齐要求相同。

可以使用 #pragma pack 指令来控制编译器的对齐行为，但这通常不建议使用，因为它可能导致代码在不同平台上的行为不一致。

#pragma pack(push, 1) // 设置对齐为 1 字节

struct MyStruct {
  char a;
  int b;
  short c;
};

#pragma pack(pop) // 恢复默认对齐

#include <iostream>

int main() {
  std::cout << "Size of MyStruct: " << sizeof(MyStruct) << " bytes" << std::endl;
  return 0;
}

在这个例子中，使用了 #pragma pack(push, 1) 来强制编译器以 1 字节对齐。这将导致 sizeof(MyStruct) 的结果为 7 字节 (1 + 4 + 2)。然后，使用 #pragma pack(pop) 将对齐设置恢复为默认值。

重要提示： 过度使用 #pragma pack 可能会损害性能，并可能导致代码在不同平台上的行为不一致。除非有充分的理由，否则应避免使用它。

5. 继承的内存布局

在C++中，继承关系会影响对象的内存布局。

单继承： 派生类的对象通常包含基类的成员作为其第一个部分，然后是派生类自己的成员。
多重继承： 每个基类的成员都按照声明的顺序排列在派生类对象中。
虚继承： 涉及虚基类时，情况会更复杂，因为对象中会包含指向虚基类子对象的指针 (vbtable)。

#include <iostream>

class Base {
public:
  int base_data;
};

class Derived : public Base {
public:
  int derived_data;
};

int main() {
  std::cout << "Size of Base: " << sizeof(Base) << " bytes" << std::endl;
  std::cout << "Size of Derived: " << sizeof(Derived) << " bytes" << std::endl;
  return 0;
}

在这个例子中，Derived 类继承自 Base 类。 Derived 对象的内存布局将首先包含 Base 类的 base_data 成员，然后是 Derived 类的 derived_data 成员。因此，sizeof(Derived) 的结果通常是 sizeof(Base) + sizeof(derived_data)，即 8 字节 (假设 int 是 4 字节)。

6. 虚函数和虚函数表 (vtable)

当类包含虚函数时，编译器会为该类创建一个虚函数表 (vtable)。 vtable 是一个函数指针数组，其中每个指针指向该类的虚函数的实现。每个包含虚函数的类对象都会包含一个指向其 vtable 的指针 (vptr)。

#include <iostream>

class Base {
public:
  virtual void foo() { std::cout << "Base::foo()" << std::endl; }
};

class Derived : public Base {
public:
  void foo() override { std::cout << "Derived::foo()" << std::endl; }
};

int main() {
  Base* b = new Derived();
  b->foo(); // 调用 Derived::foo()
  return 0;
}

在这个例子中，Base 类包含一个虚函数 foo()。 Derived 类覆盖了 foo() 函数。当使用 Base 类型的指针调用 foo() 函数时，实际上会调用 Derived 类的 foo() 函数。这是通过 vtable 和 vptr 实现的。每个 Base 和 Derived 对象都包含一个 vptr，该 vptr 指向其类的 vtable。当调用虚函数时，编译器会使用 vptr 和 vtable 来查找要调用的函数的地址。

Vptr 通常位于对象的内存布局的起始位置。这会增加对象的大小。

7. Empty Base Class Optimization (EBCO)

Empty Base Class Optimization (EBCO) 是一种编译器优化技术，旨在减少包含空基类的派生类的大小。如果一个基类不包含任何数据成员，并且不是最左边的基类，编译器可能会将其大小优化为零。这可以节省内存并提高性能。

#include <iostream>

class Empty {};

class NonEmpty {
public:
  int x;
};

class Derived : public Empty, public NonEmpty {
public:
  int y;
};

int main() {
  std::cout << "Size of Empty: " << sizeof(Empty) << " bytes" << std::endl;
  std::cout << "Size of NonEmpty: " << sizeof(NonEmpty) << " bytes" << std::endl;
  std::cout << "Size of Derived: " << sizeof(Derived) << " bytes" << std::endl;
  return 0;
}

在这个例子中，Empty 类不包含任何数据成员。 Derived 类继承自 Empty 和 NonEmpty。如果没有 EBCO，sizeof(Derived) 的结果可能是 sizeof(Empty) + sizeof(NonEmpty) + sizeof(y)，即 4 + 4 + 4 = 12 字节 (假设 int 是 4 字节)。但是，由于 Empty 是一个空类，编译器可以应用 EBCO 并将其大小优化为零。因此，sizeof(Derived) 的结果可能是 sizeof(NonEmpty) + sizeof(y)，即 4 + 4 = 8 字节。

注意： EBCO 并非所有编译器都支持，而且只有在基类不是最左边的基类时才能应用。最左边的基类必须占据至少一个字节的空间，以确保派生类对象的地址与其最左边的基类子对象的地址不同。这是 C++ 标准的要求。

8. 虚继承与内存布局

虚继承用于解决多重继承中的菱形继承问题，防止出现多个基类实例。虚继承会引入虚基类表指针 (vbtable pointer) ，指向虚基类表 (vbtable)。vbtable 包含了到达虚基类子对象的偏移量信息。

#include <iostream>

class Base {
public:
  int base_data;
};

class Derived1 : virtual public Base {
public:
  int derived1_data;
};

class Derived2 : virtual public Base {
public:
  int derived2_data;
};

class Final : public Derived1, public Derived2 {
public:
  int final_data;
};

int main() {
  std::cout << "Size of Base: " << sizeof(Base) << " bytes" << std::endl;
  std::cout << "Size of Derived1: " << sizeof(Derived1) << " bytes" << std::endl;
  std::cout << "Size of Derived2: " << sizeof(Derived2) << " bytes" << std::endl;
  std::cout << "Size of Final: " << sizeof(Final) << " bytes" << std::endl;
  return 0;
}

在这个例子中，Derived1 和 Derived2 都虚继承自 Base。 Final 类继承自 Derived1 和 Derived2。由于使用了虚继承，Final 对象将只包含一个 Base 类的实例，避免了菱形继承问题。但是，为了实现虚继承，编译器会在 Derived1 和 Derived2 对象中添加 vbtable 指针，这会增加它们的大小。 Final对象也需要管理对共享 Base 对象的访问。

9. 一些重要的总结

C++ 对象模型定义了对象在内存中的组织方式，包括成员的顺序、内存对齐、虚函数表指针等。
内存对齐是一种优化技术，旨在提高CPU访问内存的效率。编译器可能会在成员之间插入填充字节以确保成员的起始地址是其大小的倍数。
Empty Base Class Optimization (EBCO) 是一种编译器优化技术，旨在减少包含空基类的派生类的大小。只有在基类不是最左边的基类时才能应用。
虚继承用于解决多重继承中的菱形继承问题，防止出现多个基类实例。虚继承会引入虚基类表指针 (vbtable pointer) 。

理解 C++ 对象模型对于编写高效、可移植的代码至关重要。通过了解对象的内存布局、对齐规则以及编译器优化技术，我们可以更好地控制代码的性能和行为。

更多IT精英技术系列讲座，到智猿学院

C++对象模型：内存布局、对齐规则与Empty Base Class Optimization（EBCO）

发表回复 取消回复

发表回复取消回复