如何理解 C++ 中这两个结构体的大小（size）？
深入剖析 C++ 结构体的大小： byte 之间的奥秘
在 C++ 的世界里，我们经常会遇到 `struct`，用来组织相关的数据成员。当我们说“结构体的大小”时，我们实际上是在讨论它在内存中占据的字节数。这个数字看似简单，但背后却牵扯到编译器的优化、内存对齐等一系列复杂的机制。本文将带你深入理解 C++ 结构体的大小，揭开 byte 之间的奥秘，让你告别模棱两可的猜测，真正掌握内存的布局。
一、 基础概念：数据成员的直接叠加？
最直观的想法是，结构体的大小就是其所有数据成员大小的总和。比如，一个只包含一个 `int` 的结构体，大小自然就是 `sizeof(int)`。
```c++
struct Simple {
int a;
};
// sizeof(Simple) == sizeof(int)
```
如果结构体包含多个成员呢？
```c++
struct MultiMembers {
int a;
char b;
double c;
};
// 乍一看，似乎是 sizeof(int) + sizeof(char) + sizeof(double)
```
但事实并非如此简单。 C++ 标准并没有规定结构体成员必须紧密排列，编译器为了提高效率，会引入一个叫做内存对齐（Memory Alignment）的概念。
二、 内存对齐：编译器的小心思
内存对齐是指，编译器在为结构体分配内存时，会根据数据类型的大小，将成员放置在特定的内存地址上。这样做有几个主要原因：
1. 硬件访问效率: 许多现代处理器一次读取数据的最小单位是字（word），通常是 4 或 8 个字节。如果数据成员没有按照特定的规则对齐，处理器可能需要多次内存访问才能读取一个完整的成员，或者需要进行额外的位操作来提取所需数据，这会大大降低访问速度。
2. 原子操作的便利性: 一些硬件指令（如原子操作）只能在对齐的内存地址上执行。
3. 跨平台兼容性: 遵循内存对齐规则有助于在不同的硬件平台和操作系统上保持代码的一致性和可移植性。
内存对齐遵循以下规则：
每个成员的偏移量（offset）必须是其自身大小的整数倍。
结构体的总大小必须是其最大成员大小的整数倍。
我们来分析上面的 `MultiMembers` 结构体：
假设 `int` 是 4 字节，`char` 是 1 字节，`double` 是 8 字节。
如果没有内存对齐，`sizeof(MultiMembers)` 就是 `4 + 1 + 8 = 13` 字节。
但有了内存对齐，编译器会这样安排：
| 成员 | 大小 (字节) | 对齐要求 | 偏移量 (起始地址设为 0) | 实际存放位置 | 填充 (Padding) |
| : | : | : | : | : | : |
| `a` | 4 | 4 的倍数 | 0 | 地址 0 开始，占用 03 | 无 |
| `b` | 1 | 1 的倍数 | 4 | 地址 4 | 3 字节 (地址 57) |
| `c` | 8 | 8 的倍数 | 8 (因为 4+1+3=8 是 8 的倍数) | 地址 8 开始，占用 815 | 无 |
`a`：类型是 `int` (4 字节)，自然对齐要求是 4。从地址 0 开始，偏移量为 0，是 4 的倍数。占用 4 个字节（地址 03）。
`b`：类型是 `char` (1 字节)，对齐要求是 1。下一个可用的地址是 4。4 是 1 的倍数，所以 `b` 放在地址 4。
关键点来了： 接着是 `double` 类型 (8 字节)，它要求 8 字节对齐。下一个可用地址是 5。但是，5 不是 8 的倍数。为了满足 8 字节对齐，编译器会在 `b` 和 `c` 之间插入 3 个字节的填充（padding）。这样，`c` 就可以从地址 8 开始存放，而 8 是 8 的倍数。`c` 占用 8 个字节（地址 815）。
现在，结构体中已经使用了 16 个字节（地址 015）。结构体的总大小必须是其最大成员（`double`，8 字节）的整数倍。 16 已经是 8 的倍数，所以不需要再进行填充。
因此，`sizeof(MultiMembers)` 在这个典型的对齐规则下是 16 字节。
我们看到，原本 13 字节的成员，经过内存对齐后变成了 16 字节，多了 3 个字节的填充。
三、 影响结构体大小的关键因素
1. 成员的声明顺序: 这是影响结构体大小的最直接因素。将较小的成员放在前面，可以减少中间的填充，从而可能减小整体大小。
```c++
struct Order1 {
char a; // 1 byte
int b; // 4 bytes
char c; // 1 byte
};
// 对齐后可能大小：1 (a) + 3 (padding) + 4 (b) + 1 (c) + 3 (padding) = 12 字节 (如果 int 最大)
// 或 1 (a) + 3 (padding) + 4 (b) + 1 (c) + 7 (padding) = 16 字节 (如果 double 最大，但这里没有 double)
// 假设最大对齐是 int 的 4 字节，那么总大小是 12
struct Order2 {
int b; // 4 bytes
char a; // 1 byte
char c; // 1 byte
};
// 对齐后可能大小：4 (b) + 1 (a) + 1 (c) + 2 (padding) = 8 字节 (如果 int 最大)
```
在 `Order1` 中，`char a`（1字节）后需要 3 字节填充才能对齐 `int b`（4字节）。然后 `int b` 占用 4 字节。接着 `char c`（1字节）放在紧接着的地址。由于 `int b` 是 4 字节对齐，所以结构体大小需要是 4 的倍数。`1 + 3 + 4 + 1 = 9`。下一个 4 的倍数是 12。所以 `Order1` 可能是 12 字节。
在 `Order2` 中，`int b` 先放，占用 4 字节。然后 `char a` 放在地址 4，`char c` 放在地址 5。总共 6 字节。最大对齐是 4 字节。所以需要填充到 4 的倍数，即 8 字节。所以 `Order2` 可能是 8 字节。
结论： `Order2` 更小。
2. 数据类型的大小: 不同类型有不同的基本对齐要求。常见的有：
`char`: 1 字节
`short`: 2 字节
`int`: 4 字节 (通常)
`long`: 4 或 8 字节 (取决于平台)
`long long`: 8 字节
`float`: 4 字节
`double`: 8 字节
指针: 4 或 8 字节 (取决于平台)
3. 结构体本身的最大成员: 如前所述，结构体的最终大小必须是其所有成员中最大对齐要求的整数倍。如果一个结构体包含一个 `double` (8 字节)，那么即使其他成员加起来很小，结构体的总大小也至少是 8 的倍数。
4. 编译器选项和平台:
`pragma pack` 指令: 这是一个编译器指令，可以用来修改默认的内存对齐方式。例如，`pragma pack(push, 1)` 会告诉编译器按照 1 字节对齐，这会消除所有的填充，但可能会牺牲性能。
```c++
pragma pack(push, 1) // 强制 1 字节对齐
struct PackedStruct {
int a; // 4 bytes
char b; // 1 byte
double c; // 8 bytes
};
pragma pack(pop)
// sizeof(PackedStruct) == 4 + 1 + 8 = 13 字节
```
注意： 使用 `pragma pack` 会影响性能，并且在跨平台开发时需要谨慎使用。
编译器默认设置: 不同的编译器（GCC, Clang, MSVC）和编译选项可能会有不同的默认对齐设置。
目标平台架构: 32 位和 64 位系统在指针大小和对齐要求上可能有所不同。
四、 示例解析：实战演练
让我们来看几个更复杂的例子，来巩固理解。
例 1：嵌套结构体
```c++
struct Inner {
char c1; // 1 byte
int i; // 4 bytes
char c2; // 1 byte
};
// 假设最大对齐是 int 的 4 字节
// Inner 的布局： c1 (1) + 3 (pad) + i (4) + c2 (1) + 3 (pad) = 12 字节
struct Outer {
double d; // 8 bytes
Inner in; // 12 bytes
};
// Outer 的布局：
// d (8 bytes) 地址 07
// in.c1 (1 byte) 地址 8
// 3 bytes padding 地址 911
// in.i (4 bytes) 地址 1215
// in.c2 (1 byte) 地址 16
// 7 bytes padding 地址 1723
// 总大小是 24 字节 (8 的倍数，因为 d 是 8 字节对齐)
```
计算 `sizeof(Inner)`：
`c1` (1 byte) 需要 1 字节对齐。
下一个成员 `i` (4 字节) 需要 4 字节对齐。在 `c1` 之后，第一个可用的地址是 1。为了满足 4 字节对齐，需要从地址 4 开始存放 `i`。因此，`c1` 之后需要 3 字节的填充。
`i` 占用 4 字节。
下一个成员 `c2` (1 字节) 需要 1 字节对齐。它紧接着 `i` 之后，从地址 `4 + 4 = 8` 开始。
此时，结构体已用空间为 `1 + 3 + 4 + 1 = 9` 字节。
结构体的总大小必须是其最大成员（`i`，4 字节）的整数倍。 9 字节不是 4 的倍数。下一个 4 的倍数是 12。
所以，`sizeof(Inner)` 是 12 字节。
计算 `sizeof(Outer)`：
`d` (8 字节) 需要 8 字节对齐。从地址 0 开始存放，占用 8 字节。
下一个成员 `in` (大小为 12 字节)。我们需要考虑 `in` 这个结构体内部的对齐以及 `Outer` 结构体自身的对齐要求。 `in` 结构体的最大成员是 `int i`，它需要 4 字节对齐。 `Outer` 结构体包含 `double d`，需要 8 字节对齐。所以 `Outer` 的对齐要求由 `double d` 决定，即 8 字节。
`d` 已经占用地址 07。下一个可用地址是 8。
我们需要将 `in` 结构体放置在 8 字节对齐的位置上。地址 8 是 8 的倍数，所以 `in` 可以从地址 8 开始放置。
`in` 占用的内存是 12 字节。所以它占用地址 819。
此时，结构体已用空间为 `8 (d) + 12 (in) = 20` 字节。
结构体的总大小必须是其最大成员 (`d`，8 字节) 的整数倍。 20 不是 8 的倍数。下一个 8 的倍数是 24。
所以，`sizeof(Outer)` 是 24 字节。
例 2：使用不同数据类型
```c++
struct Mixed {
char c; // 1 byte
short s; // 2 bytes
double d; // 8 bytes
long l; // 4 bytes (假设)
};
```
计算 `sizeof(Mixed)` (假设 `int`, `short` 对齐是自身大小，`double` 是 8，`long` 是 4)：
最大对齐要求是 `double` 的 8 字节。
| 成员 | 大小 (字节) | 对齐要求 | 偏移量 (起始地址设为 0) | 实际存放位置 | 填充 (Padding) |
| : | : | : | : | : | : |
| `c` | 1 | 1 的倍数 | 0 | 地址 0 | 0 |
| `s` | 2 | 2 的倍数 | 1 | 地址 1 | 1 字节 (地址 2) |
| `d` | 8 | 8 的倍数 | 3 (1+2+1=4) | 地址 4 (不是 8 的倍数) | 重新计算 |
让我们重新计算，考虑每个成员的对齐要求。
1. `c` (1 byte, align 1): 放在地址 0。占用地址 0。
2. `s` (2 bytes, align 2): 下一个可用地址是 1。为了 2 字节对齐，`s` 需要从地址 2 开始。所以 `c` 后面需要 1 个字节的填充。 `s` 放在地址 2。占用地址 23。
3. `d` (8 bytes, align 8): 下一个可用地址是 4。为了 8 字节对齐，`d` 需要从地址 8 开始。所以 `s` 后面需要 `8 4 = 4` 个字节的填充。 `d` 放在地址 8。占用地址 815。
4. `l` (4 bytes, align 4): 下一个可用地址是 16。16 是 4 的倍数，所以 `l` 可以从地址 16 开始。占用地址 1619。
总已用字节数： `1 (c) + 1 (pad) + 2 (s) + 4 (pad) + 8 (d) + 4 (l) = 20` 字节。
结构体总大小必须是最大对齐（8 字节）的整数倍。 20 不是 8 的倍数。下一个 8 的倍数是 24。
所以，`sizeof(Mixed)` 是 24 字节。
五、 如何确定结构体大小？
在你的代码中，最准确的方法是使用 `sizeof` 操作符。
```c++
include
struct MyStruct {
int a;
char b;
double c;
};
struct AnotherStruct {
char c1;
int i;
char c2;
};
struct NestedStruct {
char c1; // 1 byte
int i; // 4 bytes
char c2; // 1 byte
};
struct OuterStruct {
double d; // 8 bytes
NestedStruct in;
};
int main() {
std::cout << "sizeof(MyStruct): " << sizeof(MyStruct) << std::endl;
std::cout << "sizeof(AnotherStruct): " << sizeof(AnotherStruct) << std::endl;
std::cout << "sizeof(NestedStruct): " << sizeof(NestedStruct) << std::endl;
std::cout << "sizeof(OuterStruct): " << sizeof(OuterStruct) << std::endl;
// 演示 pragma pack
pragma pack(push, 1)
struct PackedStruct {
int a;
char b;
double c;
};
pragma pack(pop)
std::cout << "sizeof(PackedStruct): " << sizeof(PackedStruct) << std::endl;
return 0;
}
```
运行上述代码，输出结果（在大多数 64 位系统上）：
```
sizeof(MyStruct): 16
sizeof(AnotherStruct): 12
sizeof(NestedStruct): 12
sizeof(OuterStruct): 24
sizeof(PackedStruct): 13
```
与我们前面的手动分析进行对照，结果是一致的。
`MyStruct`: `int`(4) + 3(pad) + `char`(1) + 7(pad) + `double`(8) = 23，下一个 8 的倍数是 24？ 噢！这里我们又犯了一个细节错误。再来看 `MyStruct`：
`a` (int, 4 bytes, align 4): 偏移 0，占用 03。
`b` (char, 1 byte, align 1): 下一个地址是 4。 4 是 1 的倍数。 `b` 占用地址 4。
`c` (double, 8 bytes, align 8): 下一个地址是 5。 5 不是 8 的倍数。需要 3 个字节填充。 `c` 占用地址 8。占用地址 815。
总共已用 `4 + 1 + 8 = 13` 字节。
最大对齐是 8。下一个 8 的倍数是 16。
所以 `sizeof(MyStruct)` 是 16 字节。
`AnotherStruct`: `char`(1) + 3(pad) + `int`(4) + `char`(1) + 3(pad) = 12 字节 (最大对齐 4)。 结果一致。
`NestedStruct`: `char`(1) + 3(pad) + `int`(4) + `char`(1) + 3(pad) = 12 字节 (最大对齐 4)。 结果一致。
`OuterStruct`: `double`(8) + `NestedStruct`(12)。 `OuterStruct` 最大对齐是 `double` 的 8 字节。 `NestedStruct` 的对齐要求是 4 字节。因此，`OuterStruct` 从 8 字节对齐开始。 `d` 占用地址 07。 `in` 可以从地址 8 开始，占用 12 字节，地址 819。已用 20 字节。最大对齐是 8。下一个 8 的倍数是 24。 结果一致。
`PackedStruct`: 强制 1 字节对齐，大小就是成员之和 `4 + 1 + 8 = 13`。 结果一致。
六、 总结与建议
理解结构体大小的关键在于掌握内存对齐的概念。编译器为了性能会进行填充，这可能会导致结构体大小大于成员大小之和。
声明顺序很重要： 将相同或接近对齐要求的成员放在一起，或者将大型成员放在前面，通常能得到更紧凑的结构体。
了解数据类型的对齐要求： 不同的类型有不同的对齐需求。
最大成员决定最终对齐： 结构体的总大小会受到其最大成员对齐要求的制约。
`sizeof` 是真理： 在不确定的情况下，永远使用 `sizeof` 来获取准确的大小。
谨慎使用 `pragma pack`： 它会影响性能，且可能降低代码的可移植性。只有在确实需要减小内存占用，并且理解其影响时才考虑使用。
通过深入理解内存对齐，你不仅能更准确地预测和控制 C++ 结构体的大小，还能在优化内存使用和性能方面做出更明智的决策。这对于处理大量数据、网络通信或嵌入式系统编程尤其重要。下次当你看到一个结构体时，不再是模糊的猜测，而是能够清晰地勾勒出它在内存中的“画像”。
在 C++ 的世界里，我们经常会遇到 `struct`，用来组织相关的数据成员。当我们说“结构体的大小”时，我们实际上是在讨论它在内存中占据的字节数。这个数字看似简单，但背后却牵扯到编译器的优化、内存对齐等一系列复杂的机制。本文将带你深入理解 C++ 结构体的大小，揭开 byte 之间的奥秘，让你告别模棱两可的猜测，真正掌握内存的布局。
一、 基础概念：数据成员的直接叠加？
最直观的想法是，结构体的大小就是其所有数据成员大小的总和。比如，一个只包含一个 `int` 的结构体，大小自然就是 `sizeof(int)`。
```c++
struct Simple {
int a;
};
// sizeof(Simple) == sizeof(int)
```
如果结构体包含多个成员呢？
```c++
struct MultiMembers {
int a;
char b;
double c;
};
// 乍一看，似乎是 sizeof(int) + sizeof(char) + sizeof(double)
```
但事实并非如此简单。 C++ 标准并没有规定结构体成员必须紧密排列，编译器为了提高效率，会引入一个叫做内存对齐（Memory Alignment）的概念。
二、 内存对齐：编译器的小心思
内存对齐是指，编译器在为结构体分配内存时，会根据数据类型的大小，将成员放置在特定的内存地址上。这样做有几个主要原因：
1. 硬件访问效率: 许多现代处理器一次读取数据的最小单位是字（word），通常是 4 或 8 个字节。如果数据成员没有按照特定的规则对齐，处理器可能需要多次内存访问才能读取一个完整的成员，或者需要进行额外的位操作来提取所需数据，这会大大降低访问速度。
2. 原子操作的便利性: 一些硬件指令（如原子操作）只能在对齐的内存地址上执行。
3. 跨平台兼容性: 遵循内存对齐规则有助于在不同的硬件平台和操作系统上保持代码的一致性和可移植性。
内存对齐遵循以下规则：
每个成员的偏移量（offset）必须是其自身大小的整数倍。
结构体的总大小必须是其最大成员大小的整数倍。
我们来分析上面的 `MultiMembers` 结构体：
假设 `int` 是 4 字节，`char` 是 1 字节，`double` 是 8 字节。
如果没有内存对齐，`sizeof(MultiMembers)` 就是 `4 + 1 + 8 = 13` 字节。
但有了内存对齐，编译器会这样安排：
| 成员 | 大小 (字节) | 对齐要求 | 偏移量 (起始地址设为 0) | 实际存放位置 | 填充 (Padding) |
| : | : | : | : | : | : |
| `a` | 4 | 4 的倍数 | 0 | 地址 0 开始，占用 03 | 无 |
| `b` | 1 | 1 的倍数 | 4 | 地址 4 | 3 字节 (地址 57) |
| `c` | 8 | 8 的倍数 | 8 (因为 4+1+3=8 是 8 的倍数) | 地址 8 开始，占用 815 | 无 |
`a`：类型是 `int` (4 字节)，自然对齐要求是 4。从地址 0 开始，偏移量为 0，是 4 的倍数。占用 4 个字节（地址 03）。
`b`：类型是 `char` (1 字节)，对齐要求是 1。下一个可用的地址是 4。4 是 1 的倍数，所以 `b` 放在地址 4。
关键点来了： 接着是 `double` 类型 (8 字节)，它要求 8 字节对齐。下一个可用地址是 5。但是，5 不是 8 的倍数。为了满足 8 字节对齐，编译器会在 `b` 和 `c` 之间插入 3 个字节的填充（padding）。这样，`c` 就可以从地址 8 开始存放，而 8 是 8 的倍数。`c` 占用 8 个字节（地址 815）。
现在，结构体中已经使用了 16 个字节（地址 015）。结构体的总大小必须是其最大成员（`double`，8 字节）的整数倍。 16 已经是 8 的倍数，所以不需要再进行填充。
因此，`sizeof(MultiMembers)` 在这个典型的对齐规则下是 16 字节。
我们看到，原本 13 字节的成员，经过内存对齐后变成了 16 字节，多了 3 个字节的填充。
三、 影响结构体大小的关键因素
1. 成员的声明顺序: 这是影响结构体大小的最直接因素。将较小的成员放在前面，可以减少中间的填充，从而可能减小整体大小。
```c++
struct Order1 {
char a; // 1 byte
int b; // 4 bytes
char c; // 1 byte
};
// 对齐后可能大小：1 (a) + 3 (padding) + 4 (b) + 1 (c) + 3 (padding) = 12 字节 (如果 int 最大)
// 或 1 (a) + 3 (padding) + 4 (b) + 1 (c) + 7 (padding) = 16 字节 (如果 double 最大，但这里没有 double)
// 假设最大对齐是 int 的 4 字节，那么总大小是 12
struct Order2 {
int b; // 4 bytes
char a; // 1 byte
char c; // 1 byte
};
// 对齐后可能大小：4 (b) + 1 (a) + 1 (c) + 2 (padding) = 8 字节 (如果 int 最大)
```
在 `Order1` 中，`char a`（1字节）后需要 3 字节填充才能对齐 `int b`（4字节）。然后 `int b` 占用 4 字节。接着 `char c`（1字节）放在紧接着的地址。由于 `int b` 是 4 字节对齐，所以结构体大小需要是 4 的倍数。`1 + 3 + 4 + 1 = 9`。下一个 4 的倍数是 12。所以 `Order1` 可能是 12 字节。
在 `Order2` 中，`int b` 先放，占用 4 字节。然后 `char a` 放在地址 4，`char c` 放在地址 5。总共 6 字节。最大对齐是 4 字节。所以需要填充到 4 的倍数，即 8 字节。所以 `Order2` 可能是 8 字节。
结论： `Order2` 更小。
2. 数据类型的大小: 不同类型有不同的基本对齐要求。常见的有：
`char`: 1 字节
`short`: 2 字节
`int`: 4 字节 (通常)
`long`: 4 或 8 字节 (取决于平台)
`long long`: 8 字节
`float`: 4 字节
`double`: 8 字节
指针: 4 或 8 字节 (取决于平台)
3. 结构体本身的最大成员: 如前所述，结构体的最终大小必须是其所有成员中最大对齐要求的整数倍。如果一个结构体包含一个 `double` (8 字节)，那么即使其他成员加起来很小，结构体的总大小也至少是 8 的倍数。
4. 编译器选项和平台:
`pragma pack` 指令: 这是一个编译器指令，可以用来修改默认的内存对齐方式。例如，`pragma pack(push, 1)` 会告诉编译器按照 1 字节对齐，这会消除所有的填充，但可能会牺牲性能。
```c++
pragma pack(push, 1) // 强制 1 字节对齐
struct PackedStruct {
int a; // 4 bytes
char b; // 1 byte
double c; // 8 bytes
};
pragma pack(pop)
// sizeof(PackedStruct) == 4 + 1 + 8 = 13 字节
```
注意： 使用 `pragma pack` 会影响性能，并且在跨平台开发时需要谨慎使用。
编译器默认设置: 不同的编译器（GCC, Clang, MSVC）和编译选项可能会有不同的默认对齐设置。
目标平台架构: 32 位和 64 位系统在指针大小和对齐要求上可能有所不同。
四、 示例解析：实战演练
让我们来看几个更复杂的例子，来巩固理解。
例 1：嵌套结构体
```c++
struct Inner {
char c1; // 1 byte
int i; // 4 bytes
char c2; // 1 byte
};
// 假设最大对齐是 int 的 4 字节
// Inner 的布局： c1 (1) + 3 (pad) + i (4) + c2 (1) + 3 (pad) = 12 字节
struct Outer {
double d; // 8 bytes
Inner in; // 12 bytes
};
// Outer 的布局：
// d (8 bytes) 地址 07
// in.c1 (1 byte) 地址 8
// 3 bytes padding 地址 911
// in.i (4 bytes) 地址 1215
// in.c2 (1 byte) 地址 16
// 7 bytes padding 地址 1723
// 总大小是 24 字节 (8 的倍数，因为 d 是 8 字节对齐)
```
计算 `sizeof(Inner)`：
`c1` (1 byte) 需要 1 字节对齐。
下一个成员 `i` (4 字节) 需要 4 字节对齐。在 `c1` 之后，第一个可用的地址是 1。为了满足 4 字节对齐，需要从地址 4 开始存放 `i`。因此，`c1` 之后需要 3 字节的填充。
`i` 占用 4 字节。
下一个成员 `c2` (1 字节) 需要 1 字节对齐。它紧接着 `i` 之后，从地址 `4 + 4 = 8` 开始。
此时，结构体已用空间为 `1 + 3 + 4 + 1 = 9` 字节。
结构体的总大小必须是其最大成员（`i`，4 字节）的整数倍。 9 字节不是 4 的倍数。下一个 4 的倍数是 12。
所以，`sizeof(Inner)` 是 12 字节。
计算 `sizeof(Outer)`：
`d` (8 字节) 需要 8 字节对齐。从地址 0 开始存放，占用 8 字节。
下一个成员 `in` (大小为 12 字节)。我们需要考虑 `in` 这个结构体内部的对齐以及 `Outer` 结构体自身的对齐要求。 `in` 结构体的最大成员是 `int i`，它需要 4 字节对齐。 `Outer` 结构体包含 `double d`，需要 8 字节对齐。所以 `Outer` 的对齐要求由 `double d` 决定，即 8 字节。
`d` 已经占用地址 07。下一个可用地址是 8。
我们需要将 `in` 结构体放置在 8 字节对齐的位置上。地址 8 是 8 的倍数，所以 `in` 可以从地址 8 开始放置。
`in` 占用的内存是 12 字节。所以它占用地址 819。
此时，结构体已用空间为 `8 (d) + 12 (in) = 20` 字节。
结构体的总大小必须是其最大成员 (`d`，8 字节) 的整数倍。 20 不是 8 的倍数。下一个 8 的倍数是 24。
所以，`sizeof(Outer)` 是 24 字节。
例 2：使用不同数据类型
```c++
struct Mixed {
char c; // 1 byte
short s; // 2 bytes
double d; // 8 bytes
long l; // 4 bytes (假设)
};
```
计算 `sizeof(Mixed)` (假设 `int`, `short` 对齐是自身大小，`double` 是 8，`long` 是 4)：
最大对齐要求是 `double` 的 8 字节。
| 成员 | 大小 (字节) | 对齐要求 | 偏移量 (起始地址设为 0) | 实际存放位置 | 填充 (Padding) |
| : | : | : | : | : | : |
| `c` | 1 | 1 的倍数 | 0 | 地址 0 | 0 |
| `s` | 2 | 2 的倍数 | 1 | 地址 1 | 1 字节 (地址 2) |
| `d` | 8 | 8 的倍数 | 3 (1+2+1=4) | 地址 4 (不是 8 的倍数) | 重新计算 |
让我们重新计算，考虑每个成员的对齐要求。
1. `c` (1 byte, align 1): 放在地址 0。占用地址 0。
2. `s` (2 bytes, align 2): 下一个可用地址是 1。为了 2 字节对齐，`s` 需要从地址 2 开始。所以 `c` 后面需要 1 个字节的填充。 `s` 放在地址 2。占用地址 23。
3. `d` (8 bytes, align 8): 下一个可用地址是 4。为了 8 字节对齐，`d` 需要从地址 8 开始。所以 `s` 后面需要 `8 4 = 4` 个字节的填充。 `d` 放在地址 8。占用地址 815。
4. `l` (4 bytes, align 4): 下一个可用地址是 16。16 是 4 的倍数，所以 `l` 可以从地址 16 开始。占用地址 1619。
总已用字节数： `1 (c) + 1 (pad) + 2 (s) + 4 (pad) + 8 (d) + 4 (l) = 20` 字节。
结构体总大小必须是最大对齐（8 字节）的整数倍。 20 不是 8 的倍数。下一个 8 的倍数是 24。
所以，`sizeof(Mixed)` 是 24 字节。
五、 如何确定结构体大小？
在你的代码中，最准确的方法是使用 `sizeof` 操作符。
```c++
include
struct MyStruct {
int a;
char b;
double c;
};
struct AnotherStruct {
char c1;
int i;
char c2;
};
struct NestedStruct {
char c1; // 1 byte
int i; // 4 bytes
char c2; // 1 byte
};
struct OuterStruct {
double d; // 8 bytes
NestedStruct in;
};
int main() {
std::cout << "sizeof(MyStruct): " << sizeof(MyStruct) << std::endl;
std::cout << "sizeof(AnotherStruct): " << sizeof(AnotherStruct) << std::endl;
std::cout << "sizeof(NestedStruct): " << sizeof(NestedStruct) << std::endl;
std::cout << "sizeof(OuterStruct): " << sizeof(OuterStruct) << std::endl;
// 演示 pragma pack
pragma pack(push, 1)
struct PackedStruct {
int a;
char b;
double c;
};
pragma pack(pop)
std::cout << "sizeof(PackedStruct): " << sizeof(PackedStruct) << std::endl;
return 0;
}
```
运行上述代码，输出结果（在大多数 64 位系统上）：
```
sizeof(MyStruct): 16
sizeof(AnotherStruct): 12
sizeof(NestedStruct): 12
sizeof(OuterStruct): 24
sizeof(PackedStruct): 13
```
与我们前面的手动分析进行对照，结果是一致的。
`MyStruct`: `int`(4) + 3(pad) + `char`(1) + 7(pad) + `double`(8) = 23，下一个 8 的倍数是 24？ 噢！这里我们又犯了一个细节错误。再来看 `MyStruct`：
`a` (int, 4 bytes, align 4): 偏移 0，占用 03。
`b` (char, 1 byte, align 1): 下一个地址是 4。 4 是 1 的倍数。 `b` 占用地址 4。
`c` (double, 8 bytes, align 8): 下一个地址是 5。 5 不是 8 的倍数。需要 3 个字节填充。 `c` 占用地址 8。占用地址 815。
总共已用 `4 + 1 + 8 = 13` 字节。
最大对齐是 8。下一个 8 的倍数是 16。
所以 `sizeof(MyStruct)` 是 16 字节。
`AnotherStruct`: `char`(1) + 3(pad) + `int`(4) + `char`(1) + 3(pad) = 12 字节 (最大对齐 4)。 结果一致。
`NestedStruct`: `char`(1) + 3(pad) + `int`(4) + `char`(1) + 3(pad) = 12 字节 (最大对齐 4)。 结果一致。
`OuterStruct`: `double`(8) + `NestedStruct`(12)。 `OuterStruct` 最大对齐是 `double` 的 8 字节。 `NestedStruct` 的对齐要求是 4 字节。因此，`OuterStruct` 从 8 字节对齐开始。 `d` 占用地址 07。 `in` 可以从地址 8 开始，占用 12 字节，地址 819。已用 20 字节。最大对齐是 8。下一个 8 的倍数是 24。 结果一致。
`PackedStruct`: 强制 1 字节对齐，大小就是成员之和 `4 + 1 + 8 = 13`。 结果一致。
六、 总结与建议
理解结构体大小的关键在于掌握内存对齐的概念。编译器为了性能会进行填充，这可能会导致结构体大小大于成员大小之和。
声明顺序很重要： 将相同或接近对齐要求的成员放在一起，或者将大型成员放在前面，通常能得到更紧凑的结构体。
了解数据类型的对齐要求： 不同的类型有不同的对齐需求。
最大成员决定最终对齐： 结构体的总大小会受到其最大成员对齐要求的制约。
`sizeof` 是真理： 在不确定的情况下，永远使用 `sizeof` 来获取准确的大小。
谨慎使用 `pragma pack`： 它会影响性能，且可能降低代码的可移植性。只有在确实需要减小内存占用，并且理解其影响时才考虑使用。
通过深入理解内存对齐，你不仅能更准确地预测和控制 C++ 结构体的大小，还能在优化内存使用和性能方面做出更明智的决策。这对于处理大量数据、网络通信或嵌入式系统编程尤其重要。下次当你看到一个结构体时，不再是模糊的猜测，而是能够清晰地勾勒出它在内存中的“画像”。
网友意见
对齐这种事情不用特别纠结一个通用规则，实际上是很复杂的。
基本原则有几条：
- 只有一个成员的话，不启动对齐规则
- 对齐大小一般按照第一个成员来计算（有例外）
- 如果相邻两个成员大小总和小于一个对齐大小，可能会挤进一个对齐单元里：
struct Test { int a; char b; short c; }; //sizeof(struct Test) = 8
但不管怎么样，总是有例外的：
struct Test { short a; char b[3]; int c; }; 这个结构体的大小是12，看样子是4*3的对齐方式？
不对，用offsetof看一下就知道，3个成员分别占2、6、4字节。
总之，对齐这种事情，知道有这么回事就行了，没必要细究一个放之四海而皆准的规则出来。具体实现是和编译器、平台、位宽等都有关系的。你真想严格按照你的想法去布置内存的话，直接用1对齐，然后自己用unused填空吧。
类似的话题
-
深入剖析 C++ 结构体的大小： byte 之间的奥秘在 C++ 的世界里，我们经常会遇到 `struct`，用来组织相关的数据成员。当我们说“结构体的大小”时，我们实际上是在讨论它在内存中占据的字节数。这个数字看似简单，但背后却牵扯到编译器的优化、内存对齐等一系列复杂的机制。本文将带你深入理解 C............. -
在C++里，谈到“堆区开辟的属性”，咱们得先明白这指的是什么。简单来说，就是程序在运行的时候，动态地在内存的一个叫做“堆”（Heap）的地方分配了一块空间，用来存放某个对象或者数据。这块内存不像那些直接定义在类里的成员变量那样，跟随着对象的生命周期一起被自动管理。堆上的内存，需要我们手动去申请（比如.............
-
这句话“C++缺少对象级别的消息发送机制”是一个比较经典且深刻的讨论点，它揭示了C++与某些其他面向对象语言（如Smalltalk或ObjectiveC）在设计哲学上的一个关键差异。要理解这句话，我们需要先回顾一下什么是“消息发送”，以及C++是如何处理对象交互的。1. 什么是“消息发送”（Mess.............
-
来，咱们聊聊 C++11 里的那些内存顺序（Memory Order）。这东西刚听着有点玄乎，但弄明白了，你会发现它在多线程的世界里简直是个宝贝，能帮你解决不少棘手的问题。之前我刚接触的时候也觉得脑袋疼，但多看多想，再加上一些实际的例子，感觉就通透了。先说清楚，内存顺序这玩意儿，本质上是为了控制多线.............
-
好的，我们来深入聊聊《Effective C++》第31条，关于如何降低文件间的编译依赖关系这个至关重要的话题。这不仅是为了提高编译速度，更是为了构建更易于维护、更灵活的 C++ 系统。想象一下我们正在开发一个大型 C++ 项目。随着功能的不断增加，我们不可避免地会创建越来越多的头文件（.h/.hp.............
-
理性对比歼10C与阵风：性能、定位与阵风外销244架的启示在现代空军装备的讨论中，中国歼10C和法国阵风战斗机无疑是两个绕不开的明星。它们各自代表了中法两国在三代半/四代战斗机领域的先进设计理念和技术实力，也引发了不少关于性能对比和市场前景的讨论。要理性看待这两款战机，需要深入剖析它们的性能特点、设.............
-
知乎在2018年确实完成了C轮融资，而腾讯的确是本轮的重要投资方，但说腾讯是“领投”则需要更细致地去理解。更准确地说，腾讯在知乎的C轮融资中扮演了非常关键的角色，但同时也有其他重量级资本的参与。从专业人士的角度来看，腾讯对知乎的投资并非偶然，而是基于对知乎平台价值、用户基础、商业化前景以及其在中国互.............
-
如果摆在我面前的是两个截然不同的发展方向，一个是用C++的Qt，另一个是Java的Android，我会认真权衡一番，然后根据我内心深处的职业追求和个人偏好来做出选择。首先，我可能会被Qt深深吸引。C++本身就是一门强大的语言，它赋予了开发者对硬件和内存更细致的控制能力，这对于那些追求极致性能和低延迟.............
-
这句话“文官的衣服上绣的是禽，武官的衣服上绣的是兽。披上了这身皮，我们哪一个不是衣冠禽兽”融合了历史、文化、隐喻和讽刺，需要从多个层面进行解析： 一、历史背景与服饰象征1. 古代官服制度 在中国历史上，官服的纹饰（如禽鸟、兽类）是等级制度和身份象征的重要标志。 文官：常以“禽”为纹.............
-
“自称迪士尼在逃公主”的现象在网络上出现后，引发了广泛讨论。这一说法通常指一些女性在社交媒体、论坛或网络社区中自称是“迪士尼公主”，并可能涉及身份扮演、文化认同、心理需求等多重层面。以下从多个角度详细分析这一现象的可能内涵和背景： 一、文化符号的再诠释：迪士尼公主的象征意义1. 迪士尼公主的原始形象.............
-
自由主义和新自由主义是两种重要的思想体系，它们在政治哲学、经济学和社会政策等领域具有深远的影响。以下是对这两个概念的详细解析： 一、自由主义的定义与核心特征自由主义（Liberalism）是一种以个人自由、法治、民主和理性为价值基础的政治哲学思想体系，其核心在于保障个体权利和限制国家权力。自由主义的.............
-
无政府主义（Anarchism）是一种深刻批判国家权力、追求个体自由与社会平等的政治哲学和实践运动。它并非主张“混乱”或“无序”，而是反对一切形式的强制性权威，尤其是国家对个人生活的控制。以下从多个维度深入解析这一复杂的思想体系： 一、核心定义与本质特征1. 对国家的彻底否定 无政府主义者认.............
-
“爱国家不等于爱朝廷”这句话在理解中国古代政治和文化时非常重要。它揭示了国家与政权（即朝廷）之间的区别，以及臣民对这两者的情感和责任的不同层面。要理解这句话，我们需要先拆解其中的概念： 国家（Guó Jiā）： 在古代，我们通常将其理解为国家的疆土、人民、文化、民族认同和长期的历史延续。它是根植.............
-
理解中国人民银行工作论文中提到的“东南亚国家掉入中等收入陷阱的原因之一是‘文科生太多’”这一论断，需要从多个层面进行深入分析，因为这是一个相对复杂且具有争议性的议题。下面我将尽量详细地解释其背后的逻辑和可能含义：一、 背景：中等收入陷阱首先，我们需要理解什么是“中等收入陷阱”。 定义： 中等收入.............
-
郭主席对房地产的表述“不希望房地产剧烈波动”可以从多个层面来理解，这背后反映了他对中国经济稳定和健康发展的深切关切。要详细理解这一点，我们需要从房地产在中国经济中的地位、波动可能带来的影响、以及“不剧烈波动”的具体含义等角度进行分析。一、 房地产在中国经济中的特殊地位：首先，理解为什么房地产会引起如.............
-
如何理解科幻小说《时间的二分法》？ 详细解读科幻小说《时间的二分法》（英文原名：The Time Machine），由英国著名作家赫伯特·乔治·威尔斯（H.G. Wells）于1895年创作，是科幻文学史上的经典之作。这部小说不仅为我们描绘了一个令人着迷的未来世界，更通过其深刻的社会寓言和哲学思考，.............
-
尹建莉老师关于“延迟满足是鬼话，孩子要及时满足”的观点，确实在教育界引发了不少讨论。要理解她的观点，我们需要深入探讨她为什么会提出这样的论断，以及她所强调的“及时满足”的真正含义。首先，我们来拆解一下“延迟满足”这个概念及其传统理解。传统理解的“延迟满足”：延迟满足（Delayed Gratific.............
-
理解外交部发言人陆慷的说法，即“《中英联合声明》作为一个历史文件，不再具有任何现实意义”，需要从几个关键角度来解读：1. 历史文件的定义与性质： 历史文件是过去的产物： 陆慷的表述首先强调了《中英联合声明》的“历史文件”属性。这意味着它是在特定历史时期、基于当时国际政治格局和两国关系背景下签署的.............
-
杨振宁先生作为一位享誉世界的物理学家，他关于中美教育的评论引起了广泛关注和讨论。理解他的话需要从多个角度进行深入剖析，包括他所处的时代背景、他对教育本质的理解、以及他观察到的中美教育体系的差异。一、 杨振宁先生评论的时代背景与个人经历：首先，要理解杨振宁先生的话，必须考虑到他所处的时代背景和他的个人.............
-
“中国是发达国家的粉碎机”这个说法，虽然带有一定的情绪化和夸张色彩，但其核心要表达的是：中国凭借其独特的经济模式、庞大的市场规模、强大的制造能力和不断进步的科技创新，对传统发达国家在经济和产业领域构成了前所未有的挑战，并在一定程度上“粉碎”了它们原有的竞争优势和发展路径。为了详细理解这一说法，我们可.............
本站所有内容均为互联网搜索引擎提供的公开搜索信息，本站不存储任何数据与内容，任何内容与数据均与本站无关，如有需要请联系相关搜索引擎包括但不限于百度，google,bing,sogou 等
© 2025 tinynews.org All Rights Reserved. 百科问答小站 版权所有