如果你已经掌握了 C 语言结构体的基本定义和访问方式，那么这篇文章将带你深入三个"进阶但实用"的主题：结构体对齐与内存布局、联合体（Union）的妙用、位段（Bit-field）的精确控制。它们不仅是面试高频考点，更是底层开发、网络编程、嵌入式系统中天天打交道的东西。
一、结构体进阶：你真的了解结构体的内存布局吗？
1.1 为什么结构体大小不等于成员大小之和？
先看一个经典问题：
#include <stdio.h>
struct Example {
char a; // 1 字节
int b; // 4 字节
char c; // 1 字节
};
int main() {
printf("sizeof(struct Example) = %lu\n", sizeof(struct Example));
return 0;
}
你可能会猜 1 + 4 + 1 = 6 字节，但实际输出往往是 12 字节。为什么？
1.2 内存对齐规则
编译器为了提升 CPU 访问效率，会对结构体成员进行内存对齐，规则大致如下：
- 每个成员的偏移量必须是自身对齐数的整数倍。对齐数 =
min(成员自身大小, 编译器的默认对齐数)。通常 32 位系统默认对齐数是 4，64 位系统是 8。 - 结构体总大小必须是最大成员对齐数的整数倍。
用上面的 struct Example 来走一遍：
| 成员 | 大小 | 对齐数 | 偏移量 | 说明 |
|---|---|---|---|---|
a | 1 | 1 | 0 | 放在 0 号位置 |
b | 4 | 4 | 4 | 不能放 1，必须对齐到 4 的倍数 |
c | 1 | 1 | 8 | 紧接 b 之后 |
| — | — | — | — | 总大小需为最大对齐数(4)的倍数 → 补齐到 12 |
内存布局示意：
偏移: 0 1 2 3 4 5 6 7 8 9 10 11
成员: [a][pad][pad][pad][ b ][c][pad][pad][pad]
1.3 调整成员顺序来压缩空间
把相同成员换个顺序：
struct Example2 {
char a; // 1 字节
char c; // 1 字节
int b; // 4 字节
};
布局变成：
偏移: 0 1 2 3 4 5 6 7
成员: [a][c][pad][pad][ b ]
总大小 = 8 字节，比之前的 12 字节节省了 33%。
实战经验：在定义结构体时，将占用空间大的成员放在前面，或者将相同类型的成员集中在一起，可以有效减少内存浪费。
1.4 #pragma pack 手动控制对齐
如果确实需要紧凑排列（比如网络协议包、文件格式），可以用 #pragma pack：
#pragma pack(1) // 按 1 字节对齐，即取消对齐填充
struct Tight {
char a;
int b;
char c;
};
#pragma pack() // 恢复默认对齐
// sizeof(struct Tight) = 6
注意：取消对齐虽然省内存，但可能导致某些硬件平台上访问未对齐数据引发性能下降甚至硬件异常。
二、联合体（Union）：同一块内存的多种解读
2.1 基本语法
联合体与结构体语法相似，但所有成员共享同一块内存：
union Data {
int i;
float f;
char str[4];
};
union Data 的大小 = 最大成员的大小 = 4 字节。
union Data d;
d.i = 0x12345678;
printf("as float: %f\n", d.f);
printf("as bytes: %02x %02x %02x %02x\n",
d.str[0], d.str[1], d.str[2], d.str[3]);
修改 d.i 后，通过 d.str 读取，得到的是 i 在内存中的原始字节。这就是联合体的核心用途之一——类型双关（type punning） 。
2.2 实战场景一：判断机器字节序
#include <stdio.h>
int is_little_endian() {
union {
int i;
char c;
} u;
u.i = 1;
return u.c == 1; // 小端：低地址存低字节
}
int main() {
printf("This machine is %s-endian\n",
is_little_endian() ? "little" : "big");
return 0;
}
u.i = 1 在内存中如果是 01 00 00 00（小端），则 u.c 读到 1；如果是 00 00 00 01（大端），则 u.c 读到 0。
2.3 实战场景二：协议解析中的变体数据
网络协议或文件格式中，同一个字段在不同情况下代表不同类型的数据：
// 假设某个消息协议中，payload 根据 type 字段决定类型
struct Message {
int type;
union {
int int_val;
float float_val;
char text[64];
} payload;
};
使用时通过 type 字段判断当前 payload 中哪个成员有效：
struct Message msg;
msg.type = 1; // 1 表示整型
msg.payload.int_val = 100;
// ... 后续根据 type 读取对应成员
2.4 联合体与结构体的嵌套
联合体可以和结构体嵌套使用，实现更灵活的数据描述：
struct Packet {
unsigned char header;
union {
struct {
unsigned short len;
unsigned char data[256];
} cmd;
struct {
unsigned char status;
unsigned int code;
} resp;
} body;
};
三、位段（Bit-field）：精确控制每一 bit
3.1 为什么需要位段？
想象一个场景：你需要表示一个设备的状态，包含：
- 电源开关：1 bit
- 运行模式：2 bit（4 种模式）
- 错误码：3 bit（8 种错误）
- 保留位：2 bit
如果用一个 char 就够了（1 + 2 + 3 + 2 = 8 bit），但用普通结构体就得用多个 int，浪费空间且需要手动移位和掩码。位段让你可以直接按 bit 定义：
struct DeviceStatus {
unsigned int power : 1; // 1 bit
unsigned int mode : 2; // 2 bits
unsigned int errcode : 3; // 3 bits
unsigned int : 2; // 2 bits 匿名位段（占位/保留）
};
3.2 位段的内存布局
位段的内存分配规则由编译器实现定义，但常见行为是：
- 位段通常打包在同一个"存储单元"（如
unsigned int，4 字节）中。 - 如果剩余空间不够放下下一个位段，可能开辟新的存储单元。
printf("sizeof(struct DeviceStatus) = %lu\n", sizeof(struct DeviceStatus));
输出通常是 4 字节（一个 unsigned int 的大小），而不是 8 × 4 = 32 字节。
3.3 位段的读写
位段的使用方式和结构体成员一样：
struct DeviceStatus dev = {0};
dev.power = 1;
dev.mode = 2; // 00, 01, 10, 11 四种模式
dev.errcode = 5; // 错误码 5
printf("power=%u, mode=%u, errcode=%u\n",
dev.power, dev.mode, dev.errcode);
编译器会自动生成位操作和掩码指令，你无需手动写 dev |= (1 << 3) 之类的代码。
3.4 位段实战：寄存器映射
嵌入式开发中，硬件寄存器经常用位段来描述：
// 假设某个 32 位控制寄存器
struct CtrlReg {
volatile unsigned int enable : 1;
volatile unsigned int irq_mask : 8;
volatile unsigned int prescale : 4;
volatile unsigned int reserved : 19;
};
// 映射到硬件地址 0x40000000
#define CTRL_REG (*(struct CtrlReg *)0x40000000)
CTRL_REG.enable = 1;
CTRL_REG.irq_mask = 0xFF;
注意：位段的内存排列顺序（从高位到低位还是从低位到高位）是实现定义的，跨平台代码中使用位段需要格外小心。
3.5 位段的局限性
- 不能取位段成员的地址（
&dev.power是非法的），因为位段可能不占据完整的字节。 - 跨平台可移植性差：不同编译器对位段的打包方向、存储单元大小可能不同。
- 不适合网络传输：字节序和位排列顺序在不同机器上可能不一致。
四、综合实战：一个简单的数据包解析器
把结构体、联合体、位段结合起来，实现一个模拟网络数据包的解析：
#include <stdio.h>
#include <stdint.h>
#include <string.h>
// 数据包头部：用位段描述标志位
struct PacketHeader {
uint8_t version : 4; // 版本号，4 bit
uint8_t type : 4; // 包类型，4 bit
uint8_t flags : 8; // 标志位，8 bit
uint16_t length; // 数据长度，16 bit
};
// 数据包体：联合体表示不同类型的数据
union PacketBody {
uint32_t value; // 数值型数据
char text[256]; // 文本型数据
uint8_t raw[256]; // 原始字节
};
// 完整数据包
struct Packet {
struct PacketHeader header;
union PacketBody body;
};
int main() {
struct Packet pkt;
memset(&pkt, 0, sizeof(pkt));
// 填充头部
pkt.header.version = 1;
pkt.header.type = 3;
pkt.header.flags = 0x0F;
pkt.header.length = 4;
// 填充数据（数值型）
pkt.body.value = 0xDEADBEEF;
// 解析并打印
printf("Packet v%d, type=%d, flags=0x%02X, length=%d\n",
pkt.header.version, pkt.header.type,
pkt.header.flags, pkt.header.length);
printf("Body as value: 0x%08X\n", pkt.body.value);
printf("Body as bytes: ");
for (int i = 0; i < 4; i++) {
printf("%02X ", pkt.body.raw[i]);
}
printf("\n");
return 0;
}
运行输出（小端机器）：
Packet v1, type=3, flags=0x0F, length=4
Body as value: 0xDEADBEEF
Body as bytes: EF BE AD DE
这个例子展示了：
- 位段用于紧凑地描述协议头部标志
- 联合体用于同一段数据按不同类型解读
- 结构体将头部和数据体组合成完整的包
五、总结
| 特性 | 核心要点 | 典型用途 |
|---|---|---|
| 结构体对齐 | 成员按对齐数排列，总大小为最大对齐数的倍数 | 节省内存、匹配硬件/协议要求 |
| 联合体 | 所有成员共享内存，同一时刻只有一个成员有效 | 类型双关、协议变体、字节序判断 |
| 位段 | 按 bit 分配成员，编译器自动生成位操作 | 寄存器映射、标志位压缩、协议头 |
三个核心建议：
- 定义结构体时注意成员排列顺序，减少填充字节。
- 联合体是底层编程的利器，但务必通过额外字段（如
type）记录当前哪个成员有效。 - 位段不要用于跨平台数据交换，它属于"实现定义行为"的范畴。
掌握这三个工具，你就能在 C 语言的底层世界里游刃有余——无论是写网络协议栈、嵌入式驱动，还是做性能敏感的系统编程。