结构体与联合体 (Structs, Unions & Enums)

章节概述

结构体（struct）是 C 语言组织异构数据的聚合工具——将不同数据类型的变量组合成一个逻辑整体。联合体（union）则让多个成员共享同一块内存，是 C 语言实现”类型双关”（type punning）和节省内存的关键机制。枚举（enum）为整数常量提供有意义的名称。本章从 struct 的基本定义和成员访问出发，深入讲解 typedef 的类型别名、结构体的内存对齐（alignment）和填充（padding）——这是理解内存布局和 sizeof 结果的关键底层概念——以及联合体的内存共享原理、枚举的整数本质和位域（bit-field）的精细内存控制。最后从汇编层面展示结构体成员相对于基址的偏移寻址（base + offset），建立完整的内存布局心智模型。

核心主题：struct = 内存布局的艺术。理解 padding 就理解了为什么你的 sizeof(struct) 比想象中大；理解 alignment 就理解了 CPU 访问内存的效率瓶颈。本章内容直接关联后续的面向对象模拟（07_面向对象C编程）和数据结构实现（[[|]]）。

第一节：结构体定义与使用

1.1 struct 的基本语法

#include <stdio.h>
#include <string.h>
 
// 定义结构体类型
struct Student {
 char name[32];
 int age;
 double score;
}; // 注意分号！
 
int main() {
 // 声明结构体变量
 struct Student s1;
 
 // 初始化（按声明顺序）
 strcpy(s1.name, "张三");
 s1.age = 20;
 s1.score = 95.5;
 
 // 声明 + 初始化（C99 指定初始化器）
 struct Student s2 = {
 .name = "李四",
 .age = 22,
 .score = 88.0
 };
 
 // 顺序初始化（不推荐，可读性差）
 struct Student s3 = {"王五", 19, 92.0};
 
 // 成员访问：点运算符
 printf("姓名: %s, 年龄: %d, 成绩: %.1f\n",
 s1.name, s1.age, s1.score);
 
 // 结构体赋值（整体复制，包括数组成员）
 struct Student s4 = s1; // 栈上 memcpy
 s4.name[0] = 'A'; // 修改副本不影响原值
 printf("s1.name = %s, s4.name = %s\n", s1.name, s4.name);
 
 return 0;
}

1.2 指向结构体的指针（箭头运算符）

#include <stdio.h>
#include <stdlib.h>
 
struct Point {
 int x;
 int y;
};
 
int main() {
 struct Point p1 = {10, 20};
 
 // 指向结构体的指针
 struct Point *ptr = &p1;
 
 // 两种访问方式（等价）
 printf("(*ptr).x = %d\n", (*ptr).x); // 解引用 + 点运算
 printf("ptr->x = %d\n", ptr->x); // 箭头运算（推荐）
 printf("ptr->y = %d\n", ptr->y);
 
 // 通过指针修改成员
 ptr->x = 100;
 ptr->y = 200;
 printf("修改后: (%d, %d)\n", p1.x, p1.y);
 
 // 堆上分配结构体
 struct Point *heap_p = malloc(sizeof(struct Point));
 if (heap_p) {
 heap_p->x = 50;
 heap_p->y = 60;
 printf("堆上: (%d, %d)\n", heap_p->x, heap_p->y);
 free(heap_p);
 }
 
 return 0;
}

1.3 结构体数组

#include <stdio.h>
 
struct Book {
 char title[50];
 int pages;
 double price;
};
 
int main() {
 // 结构体数组
 struct Book library[3] = {
 {"C 语言程序设计", 450, 59.9},
 {"算法导论", 1312, 128.0},
 {"编译原理", 800, 89.0}
 };
 
 // 遍历
 for (int i = 0; i < 3; i++) {
 printf("《%s》%d页 ¥%.1f\n",
 library[i].title,
 library[i].pages,
 library[i].price);
 }
 
 // 修改
 library[0].price = 49.9;
 strcpy(library[2].title, "深入理解计算机系统");
 
 // 结构体数组在内存中的布局：
 // 每个结构体元素连续排列
 printf("\nsizeof(struct Book) = %zu\n", sizeof(struct Book));
 printf("数组总大小 = %zu\n", sizeof(library));
 // library[i] 的地址 = library + i * sizeof(struct Book)
 
 return 0;
}

小节练习

选择题 1

访问结构体指针 p 指向的成员 x，正确的语法是？

A. p.x

B. p->x

C. *p.x

D. &p.x

点击查看答案解析: 结构体指针使用 ->（箭头运算符）访问成员。p->x 等价于 (*p).x。. 用于直接的结构体变量。

正确答案: B

判断题 1

两个相同类型的结构体变量可以直接用 = 赋值（整体复制）。（）

正确

错误

点击查看答案解析: C 语言中相同结构体类型的变量支持整体赋值（s1 = s2），编译器会执行等同于 memcpy 的操作。但注意：如果结构体包含指针成员，只有指针值被复制（浅拷贝）。

答案: 正确

第二节：typedef 与结构体

2.1 typedef 的基本用法

#include <stdio.h>
 
// 方式1：先定义 struct，再用 typedef 取别名
struct Point {
 int x;
 int y;
};
typedef struct Point Point_t;
 
// 方式2：定义 + typedef 合一（最常见）
typedef struct {
 int x;
 int y;
} Point; // 这里 Point 是类型别名，不是 struct 标签
 
// 方式3：同时有标签和别名
typedef struct Vector {
 int x;
 int y;
 int z;
} Vector;
 
int main() {
 // 使用时不需要写 struct 关键字
 Point p1 = {10, 20};
 Vector v1 = {1, 2, 3};
 
 // 如果需要前向引用（链表），必须保留标签
 typedef struct Node {
 int data;
 struct Node *next; // 这里必须用 struct Node
 } Node;
 
 Node head = {42, NULL};
 printf("Node data: %d\n", head.data);
 
 return 0;
}

2.2 链表节点 —— typedef + 自引用结构体

#include <stdio.h>
#include <stdlib.h>
 
// 链表节点（自引用结构体）—— 必须保留 struct 标签
typedef struct ListNode {
 int value;
 struct ListNode *next; // 不能写 ListNode *next！typedef 还没完成
} ListNode;
 
// 创建新节点
ListNode *create_node(int value) {
 ListNode *node = malloc(sizeof(ListNode));
 if (node) {
 node->value = value;
 node->next = NULL;
 }
 return node;
}
 
// 打印链表
void print_list(ListNode *head) {
 for (ListNode *p = head; p != NULL; p = p->next) {
 printf("[%d] -> ", p->value);
 }
 printf("NULL\n");
}
 
int main() {
 ListNode *head = create_node(1);
 head->next = create_node(2);
 head->next->next = create_node(3);
 
 print_list(head);
 
 // 清理内存
 while (head) {
 ListNode *next = head->next;
 free(head);
 head = next;
 }
 
 return 0;
}

链表的完整实现在 02_链表中详细展开。

小节练习

选择题 1

以下自引用结构体定义正确的是？

A. typedef struct { int d; Node *n; } Node;

B. typedef struct Node { int d; struct Node *n; } Node;

C. typedef struct { int d; struct Node *n; } Node;

D. typedef Node { int d; Node *n; };

点击查看答案解析: 自引用结构体需要 struct 标签，因为 typedef 别名在定义完成后才生效。在结构体内部必须使用 struct Node（标签名），不能使用 Node（别名）。

正确答案: B

第三节：内存对齐与填充（Memory Alignment & Padding）

3.1 什么是内存对齐

CPU 访问内存时，对齐的数据比不对齐的数据更快（甚至必须对齐）。对齐规则：

char 可以在任意地址（对齐 1 字节）
short 必须对齐到 2 的倍数地址
int 必须对齐到 4 的倍数地址
double 必须对齐到 8 的倍数地址（x86-64）

#include <stdio.h>
 
int main() {
 printf("=== 基本类型的对齐要求 ===\n");
 printf("_Alignof(char) = %zu\n", _Alignof(char)); // 1
 printf("_Alignof(short) = %zu\n", _Alignof(short)); // 2
 printf("_Alignof(int) = %zu\n", _Alignof(int)); // 4
 printf("_Alignof(long) = %zu\n", _Alignof(long)); // 8
 printf("_Alignof(float) = %zu\n", _Alignof(float)); // 4
 printf("_Alignof(double) = %zu\n", _Alignof(double)); // 8
 printf("_Alignof(long long) = %zu\n", _Alignof(long long)); // 8
 
 return 0;
}

3.2 结构体填充（Padding）

编译器在结构体成员之间和结构体末尾插入不可见的填充字节，以确保每个成员满足其对齐要求。

#include <stdio.h>
#include <stddef.h>
 
// 案例1：未优化的布局（浪费空间）
struct BadLayout {
 char a; // 1B, offset 0
 // padding 3B (offset 1 不整除 4)
 int b; // 4B, offset 4
 char c; // 1B, offset 8
 // padding 7B (让结构体大小整除最大对齐 8)
 double d; // 8B, offset 16
};
// sizeof(BadLayout) = 24 字节！（padding 占了 10 字节）
 
// 案例2：优化后的布局（节省空间）
struct GoodLayout {
 double d; // 8B, offset 0
 int b; // 4B, offset 8
 char a; // 1B, offset 12
 char c; // 1B, offset 13
 // padding 2B (让结构体大小整除 8)
};
// sizeof(GoodLayout) = 16 字节！（节省 8 字节）
 
int main() {
 printf("sizeof(BadLayout) = %zu\n", sizeof(struct BadLayout));
 printf("sizeof(GoodLayout) = %zu\n", sizeof(struct GoodLayout));
 
 // 用 offsetof 查看每个成员的偏移
 printf("\n=== BadLayout 偏移 ===\n");
 printf("offsetof(a) = %zu\n", offsetof(struct BadLayout, a)); // 0
 printf("offsetof(b) = %zu\n", offsetof(struct BadLayout, b)); // 4
 printf("offsetof(c) = %zu\n", offsetof(struct BadLayout, c)); // 8
 printf("offsetof(d) = %zu\n", offsetof(struct BadLayout, d)); // 16
 
 printf("\n=== GoodLayout 偏移 ===\n");
 printf("offsetof(d) = %zu\n", offsetof(struct GoodLayout, d)); // 0
 printf("offsetof(b) = %zu\n", offsetof(struct GoodLayout, b)); // 8
 printf("offsetof(a) = %zu\n", offsetof(struct GoodLayout, a)); // 12
 printf("offsetof(c) = %zu\n", offsetof(struct GoodLayout, c)); // 13
 
 return 0;
}

3.3 内存布局可视化

graph TD
 subgraph "BadLayout (24 字节)"
 direction LR
 B0["offset 0<br/>a (char) 1B"]
 B1["offset 1-3<br/>PADDING 3B"]
 B2["offset 4-7<br/>b (int) 4B"]
 B3["offset 8<br/>c (char) 1B"]
 B4["offset 9-15<br/>PADDING 7B"]
 B5["offset 16-23<br/>d (double) 8B"]
 end
 B0 --> B1 --> B2 --> B3 --> B4 --> B5

 subgraph "GoodLayout (16 字节)"
 direction LR
 G0["offset 0-7<br/>d (double) 8B"]
 G1["offset 8-11<br/>b (int) 4B"]
 G2["offset 12<br/>a (char) 1B"]
 G3["offset 13<br/>c (char) 1B"]
 G4["offset 14-15<br/>PADDING 2B"]
 end
 G0 --> G1 --> G2 --> G3 --> G4

对齐规则总结：

每个成员的偏移必须是其对齐要求（alignment）的倍数
结构体的总大小必须是其最大成员对齐要求的倍数（含结构体末尾的填充）
成员排列顺序影响结构体的总大小
_Alignas(N) 可以手动指定对齐（C11）

3.4 手动控制对齐

#include <stdio.h>
#include <stddef.h>
 
// C11 _Alignas 指定对齐
struct AlignedExample {
 char c;
 _Alignas(16) int x; // x 的对齐要求是 16 字节
};
 
// GCC 扩展：__attribute__((packed)) 取消对齐（节省空间但可能影响性能）
struct __attribute__((packed)) Packed {
 char a;
 int b;
 char c;
 double d;
};
// sizeof(Packed) = 14（完全没有 padding！）
// 但访问 b 和 d 很慢（不对齐的访问）
 
// 编译指示（pragma pack）
#pragma pack(push, 1) // 设为 1 字节对齐
struct PackedByPragma {
 char a;
 int b; // 没有 padding，offset = 1
 double d; // 没有 padding，offset = 5
};
#pragma pack(pop) // 恢复默认对齐
// sizeof = 13
 
int main() {
 printf("sizeof(AlignedExample) = %zu\n", sizeof(struct AlignedExample));
 printf("sizeof(Packed) = %zu\n", sizeof(struct Packed));
 printf("sizeof(PackedByPragma) = %zu\n", sizeof(struct PackedByPragma));
 return 0;
}

对齐和填充是 C 语言”深入底层”的典型体现。C++ 的 struct 与 class 在内存布局上与 C struct 完全相同（多出了 vtable 指针）。比较见 CPP教程: struct结构体。

小节练习

选择题 1

x86-64 上，struct { char a; int b; } 的大小是？

A. 5 字节

B. 6 字节

C. 8 字节

D. 12 字节

点击查看答案解析: char (1B, offset 0) + padding (3B) + int (4B, offset 4) = 8 字节。结构体总大小需整除最大对齐值（4），8 满足条件。

正确答案: C

选择题 2

减少结构体填充的最佳方法是？

A. 使用 #pragma pack(1)

B. 按对齐要求从大到小排列成员

C. 全部使用 char 类型

D. 使用 __attribute__((packed))

点击查看答案解析: 将对齐要求最大的成员放在最前面可以最小化填充。A 和 D 虽然能减少大小，但会导致未对齐的内存访问（性能损失甚至在某些架构上崩溃）。

正确答案: B

第四节：联合体（union）

4.1 union 的基本概念

联合体所有成员共享同一块内存，任何时候只有一个成员是”活跃”的。

#include <stdio.h>
 
// 联合体的大小 = 最大成员的大小
union Data {
 int i; // 4 字节
 float f; // 4 字节
 char s[8]; // 8 字节
};
 
int main() {
 union Data d;
 printf("sizeof(union Data) = %zu\n", sizeof(d)); // 8
 
 // 写入 i，覆盖了前 4 字节
 d.i = 42;
 printf("d.i = %d\n", d.i);
 
 // 写入 f，覆盖了前 4 字节（i 的值丢失）
 d.f = 3.14f;
 printf("d.f = %f\n", d.f);
 printf("d.i = %d（被覆盖后的垃圾值）\n", d.i);
 
 // 写入字符串（最多 7 个字符 + \0）
 strcpy(d.s, "Hello");
 printf("d.s = %s\n", d.s);
 
 return 0;
}

graph TD
 subgraph "union Data 内存布局（8 字节）"
 direction LR
 U0["Byte 0"]
 U1["Byte 1"]
 U2["Byte 2"]
 U3["Byte 3"]
 U4["Byte 4"]
 U5["Byte 5"]
 U6["Byte 6"]
 U7["Byte 7"]
 end
 subgraph "成员映射"
 I["int i: 使用 Byte 0-3"]
 F["float f: 使用 Byte 0-3"]
 S["char s#91;8#93;: 使用 Byte 0-7"]
 end

4.2 union 的典型应用

#include <stdio.h>
#include <string.h>
 
// 应用1：类型双关（Type Punning）—— 重新解释位模式
union FloatInt {
 float f;
 unsigned int u;
};
 
void show_float_bits(float value) {
 union FloatInt fi;
 fi.f = value;
 printf("float %f 的位模式: 0x%08X\n", value, fi.u);
}
 
// 应用2：变体记录（Tagged Union）
enum DataType { TYPE_INT, TYPE_FLOAT, TYPE_STRING };
 
struct Variant {
 enum DataType type;
 union {
 int i_val;
 double f_val;
 char s_val[32];
 } data;
};
 
void print_variant(struct Variant v) {
 switch (v.type) {
 case TYPE_INT:
 printf("整数: %d\n", v.data.i_val);
 break;
 case TYPE_FLOAT:
 printf("浮点: %f\n", v.data.f_val);
 break;
 case TYPE_STRING:
 printf("字符串: %s\n", v.data.s_val);
 break;
 }
}
 
// 应用3：寄存器访问（嵌入式常用）
// 32 位寄存器可以整体访问，也可以按位域访问
union Register {
 unsigned int full;
 struct {
 unsigned int enable : 1; // bit 0
 unsigned int mode : 2; // bit 1-2
 unsigned int speed : 2; // bit 3-4
 unsigned int reserved : 27; // bit 5-31
 } bits;
};
 
int main() {
 // 类型双关演示
 show_float_bits(3.14f);
 show_float_bits(-1.0f);
 
 // 变体记录演示
 struct Variant v1 = {TYPE_INT, .data.i_val = 42};
 struct Variant v2 = {TYPE_FLOAT, .data.f_val = 3.14};
 struct Variant v3 = {TYPE_STRING, .data.s_val = "Hello"};
 print_variant(v1);
 print_variant(v2);
 print_variant(v3);
 
 // 寄存器访问演示
 union Register reg;
 reg.full = 0;
 reg.bits.enable = 1;
 reg.bits.mode = 3;
 printf("寄存器值: 0x%08X\n", reg.full);
 
 return 0;
}

C++ 使用 std::variant（C++17）提供了类型安全的变体类型，而 C 语言需要手动维护标签变量。union 的基本思想在 C++ 中仍然用于底层内存操作。

小节练习

选择题 1

union { char c; int i; double d; } 占用多少字节？

A. 1

B. 4

C. 8

D. 13

点击查看答案解析: union 的大小等于其最大成员的大小（double = 8 字节），加上可能的末尾填充以确保对齐。所有成员共享从偏移 0 开始的同一个内存块。

正确答案: C

第五节：枚举（enum）与位域（bit-field）

5.1 enum 枚举类型

#include <stdio.h>
 
// 枚举：为整数常量提供有意义的名称
enum Color {
 RED, // 0
 GREEN, // 1
 BLUE // 2
};
 
// 手动指定值
enum Status {
 OK = 200,
 NOT_FOUND = 404,
 SERVER_ERROR = 500,
 UNKNOWN // 501（自动递增前一个值）
};
 
// 二进制位标志
enum Permissions {
 READ = 1 << 0, // 0b001 = 1
 WRITE = 1 << 1, // 0b010 = 2
 EXECUTE = 1 << 2 // 0b100 = 4
};
 
int main() {
 // enum 变量本质是整数
 enum Color c = RED;
 printf("RED = %d\n", c);
 
 // enum 可以用在 switch 中
 enum Color favorite = BLUE;
 switch (favorite) {
 case RED: printf("红色\n"); break;
 case GREEN: printf("绿色\n"); break;
 case BLUE: printf("蓝色\n"); break;
 }
 
 // 位标志组合
 int my_perms = READ | WRITE; // 3
 printf("权限: %d\n", my_perms);
 if (my_perms & READ) {
 printf("有读权限\n");
 }
 
 // 遍历枚举
 for (enum Color col = RED; col <= BLUE; col++) {
 printf("Color %d\n", col);
 }
 
 return 0;
}

5.2 位域（Bit-field）

位域允许精确控制结构体成员占用的位数，常用于协议头和硬件寄存器。

#include <stdio.h>
#include <string.h>
 
// 位域示例：IPv4 数据包头（简化版）
struct IPv4Header {
 unsigned int version : 4; // 4 位
 unsigned int ihl : 4; // 4 位（首部长度）
 unsigned int dscp : 6; // 6 位（服务类型）
 unsigned int ecn : 2; // 2 位
 unsigned int total_length: 16; // 16 位
};
 
// 位域示例：CPU 状态寄存器
struct StatusRegister {
 unsigned int carry : 1; // bit 0
 unsigned int zero : 1; // bit 1
 unsigned int sign : 1; // bit 2
 unsigned int overflow : 1; // bit 3
 unsigned int : 4; // 未命名位域（占位，跳过 bit 4-7）
 unsigned int interrupt : 1; // bit 8
};
 
int main() {
 // 位域结构体大小
 printf("sizeof(IPv4Header) = %zu\n", sizeof(struct IPv4Header));
 printf("sizeof(StatusRegister) = %zu\n", sizeof(struct StatusRegister));
 
 // 使用位域
 struct IPv4Header header;
 memset(&header, 0, sizeof(header));
 header.version = 4; // IPv4
 header.ihl = 5; // 最小头长度（5 × 4 = 20 字节）
 header.total_length = 1500;
 
 printf("version = %u, ihl = %u, total_length = %u\n",
 header.version, header.ihl, header.total_length);
 
 // 状态寄存器
 struct StatusRegister sr = {0};
 sr.carry = 1;
 sr.zero = 0;
 // 位域可以用作位掩码的标志替代
 printf("carry=%u, zero=%u\n", sr.carry, sr.zero);
 
 // 位域的汇编访问：
 // 编译器将位域操作翻译为位掩码 + 移位
 // header.version = 4 → 需要读取、掩码、移位、写回
 // 比单独的结构体成员访问稍慢
 
 return 0;
}

5.3 位域的局限和注意事项

#include <stdio.h>
 
int main() {
 // 局限1：不能对位域取地址（没有独立的地址）
 struct {
 unsigned int flag : 1;
 } s;
 
 // unsigned int *p = &s.flag; // 编译错误！
 // 因为位域可能跨字节边界，没有独立的地址
 
 // 局限2：位域的大小和排列是"实现定义"的
 // 在不同编译器/平台上可能不同（大端/小端）
 
 // 局限3：位域不能用于数组
 // struct { unsigned int arr[3] : 4; }; // 编译错误
 
 // 局限4：不能做 sizeof 获取位宽（sizeof 返回的是包含类型的大小）
 printf("sizeof unsigned int: %zu\n", sizeof(unsigned int));
 
 return 0;
}

小节练习

选择题 1

枚举 enum { A, B = 5, C, D = 2, E }; 中 E 的值是？

A. 0

B. 3

C. 6

D. 7

点击查看答案解析: A=0(默认), B=5, C=6(自动+1), D=2, E=3(D 之后自动+1)。

正确答案: B

第六节：结构体在汇编层面的访问

6.1 结构体成员的汇编寻址

// C 代码
struct Point {
 int x; // offset 0
 int y; // offset 4
};
 
void set_point(struct Point *p, int x, int y) {
 p->x = x;
 p->y = y;
}

对应 x86-64 汇编（简化）：

set_point:
 movl %esi, (%rdi) ; p->x = x
 ; %rdi = p (基址), %esi = x
 ; (%rdi) = *p = p->x（offset 0）
 
 movl %edx, 4(%rdi) ; p->y = y
 ; 4(%rdi) = *(p + 4) = p->y（offset 4）
 ret

结构体成员访问的关键：编译器将 p->member 翻译为 *(base + offset) 的寻址模式。

6.2 复杂结构体的寻址

struct Inner {
 int a; // offset 0
 double b; // offset 8 (padding 4)
}; // sizeof = 16
 
struct Outer {
 char c; // offset 0
 // padding 7
 struct Inner inner; // offset 8
 int d; // offset 24
}; // sizeof = 32 (末尾 padding 4)
 
// C 代码
void set_inner_b(struct Outer *o, double val) {
 o->inner.b = val;
}

汇编：

set_inner_b:
 ; o->inner.b 的偏移 = offsetof(struct Outer, inner) + offsetof(struct Inner, b)
 ; = 8 + 8 = 16
 movsd %xmm0, 16(%rdi) ; o->inner.b = val (8 字节浮点)
 ret

offsetof 宏在编译时计算成员的字节偏移，是结构体操作的基础。汇编层面的间接寻址详细讨论见。

小节练习

选择题 1

struct { char a; int b; char c; } 中 c 的偏移是？

A. 1

B. 5

C. 8

D. 9

点击查看答案解析: a 在 offset 0 (1B)，b 必须 4 字节对齐 → padding 3B → b 在 offset 4 (4B)，c 在 offset 8 (1B)。offsetof(c) = 8。

正确答案: C

章节测试

一、判断题（正确选，错误选）

判断题 1

C 语言中 struct 和 class 的区别是 struct 不能有成员函数。（）

正确

错误

点击查看答案解析: C 语言根本没有 class 关键字！class 是 C++ 的概念。在 C++ 中 struct 也可以有成员函数，struct 与 class 的唯一区别是默认访问级别不同（struct 默认 public，class 默认 private）。

答案: 错误

判断题 2

结构体成员在内存中一定按声明的顺序排列。（）

正确

错误

点击查看答案解析: C 语言标准保证结构体成员的内存地址按声明顺序递增——第一个成员地址最低，后续成员地址依次增加。但成员之间可能有填充。

答案: 正确

判断题 3

union 的所有成员可以同时持有有效值。（）

正确

错误

点击查看答案解析: union 的所有成员共享同一块内存，写入一个成员会覆盖其他成员。任何时候只有一个成员是"活跃"的（存放有意义的值）。读取非活跃成员会得到未指定值。

答案: 错误

判断题 4

sizeof(struct) 总是等于所有成员 sizeof 之和。（）

正确

错误

点击查看答案解析: 由于对齐要求，结构体中会有填充字节。sizeof(struct) 等于成员大小之和加填充字节。例如 struct { char a; int b; } 的 sizeof 是 8，而成员大小之和是 5。

答案: 错误

判断题 5

枚举类型的变量在内存中存储的是字符串（枚举名）。（）

正确

错误

点击查看答案解析: 枚举变量存储的是整数值（通常是 int）。枚举名只是编译时的符号，不进入运行时。sizeof(enum E) = sizeof(int)（通常 4 字节）。

答案: 错误

判断题 6

位域（bit-field）成员不能使用 sizeof 运算符。（）

正确

错误

点击查看答案解析: 位域没有独立的地址（不能取 &），也不能使用 sizeof 获取其位宽。可以对其"包含类型"使用 sizeof。

答案: 正确

判断题 7

typedef struct { int x; } Point; 之后 Point 就是 struct Point 的别名。（）

正确

错误

点击查看答案解析: 该结构体没有标签（tag），所以 struct Point 不是一个合法的类型名。Point 是匿名结构体的类型别名。如果需要同时有标签和别名，需要写 typedef struct Point { ... } Point;。

答案: 错误

判断题 8

结构体的整体赋值 s1 = s2 使用的是浅拷贝（只复制指针值）。（）

正确

错误

点击查看答案解析: 结构体整体赋值执行逐字节复制（memcpy 语义）。如果结构体包含指针成员，复制的是指针值（地址），两个结构体的该指针指向同一块内存——这是浅拷贝的含义。修改 s1.ptr 指向的内容也会影响 s2.ptr。

答案: 正确

判断题 9

联合体可以用来判断系统是大端还是小端（端序检测）。（）

正确

错误

点击查看答案解析: union { int i; char c; } u; u.i = 1; 后，如果 u.c == 1 则为小端（低字节在低地址），如果 u.c == 0 则为大端。这是经典的端序检测方法。

答案: 正确

判断题 10

_Alignas 可以要求某个成员的偏移少于其自然对齐。（）

正确

错误

点击查看答案解析: _Alignas 只能增大对齐要求，不能减小。减小对齐（如将 int 改为 2 字节对齐）需要 #pragma pack 或 __attribute__((packed))，且可能产生错误对齐访问。

答案: 错误

二、选择题（单项选择题）

选择题 1

访问结构体指针 p 的成员 name，最简洁的写法是？

A. (*p).name

B. p.name

C. p->name

D. *p.name

点击查看答案解析: p->name 和 (*p).name 等价，箭头运算符专门为结构体指针设计，更简洁。p.name 需要 p 是结构体变量（不是指针），*p.name 是未定义行为（. 优先级高于 *）。

正确答案: C

选择题 2

x86-64 上 struct { double a; char b; } 的大小是？

A. 9

B. 12

C. 16

D. 17

点击查看答案解析: double (8B, offset 0) + char (1B, offset 8) + 填充 7B = 16B。总大小必须能被最大对齐值 (8) 整除，所以末尾填充 7 字节。

正确答案: C

选择题 3

offsetof(struct S, member) 返回什么？

A. member 的大小

B. member 在结构体中的字节偏移

C. 结构体总大小

D. member 的对齐值

点击查看答案解析: offsetof（定义在 <stddef.h>）返回指定成员在结构体中的字节偏移量——从结构体首地址到该成员首地址的距离。

正确答案: B

选择题 4

以下关于 union 的说法哪项正确？

A. union 可以有多个活跃成员

B. union 的大小是全部成员大小之和

C. union 的所有成员起始于同一地址

D. union 不能包含结构体成员

点击查看答案解析: union 的核心特性——所有成员从偏移 0 开始，共享同一块内存。只有 C 正确。A 错（只能一个活跃），B 错（大小为最大成员），D 错（可以包含结构体）。

正确答案: C

选择题 5

自引用结构体在定义 next 成员时，必须使用什么？

A. typedef 别名

B. struct 标签

C. void 指针

D. 无所谓

点击查看答案解析: 在结构体定义内部，typedef 别名还未生效，必须用 struct 标签名 来声明自引用指针。例如 struct Node { int d; struct Node *next; };。

正确答案: B

选择题 6

enum { X = 2, Y, Z = 6, W }; 中 W 的值是？

A. 3

B. 4

C. 5

D. 7

点击查看答案解析: X=2, Y=3（+1）, Z=6, W=7（Z 之后 +1）。枚举值的默认规则：首个为 0，后续成员默认 = 前一个成员值 + 1。

正确答案: D

选择题 7

union { int i; char c[4]; } u; u.i = 0x01020304; 在小端机器上 u.c[0] 的值是？

A. 0x01

B. 0x02

C. 0x03

D. 0x04

点击查看答案解析: 小端存储：低字节存储在低地址。0x01020304 的字节序为 04 03 02 01（从低地址到高地址）。c[0] 是地址最低字节 → 0x04。

正确答案: D

选择题 8

以下哪个声明同时创建了结构体标签和 typedef 别名？

A. struct Point { int x,y; } typedef Point;

B. typedef struct Point { int x,y; } Point;

C. typedef { int x,y; } Point;

D. struct typedef Point { int x,y; };

点击查看答案解析: B 同时创建了 struct 标签 Point（可用于自引用）和类型别名 Point（使用时不需要 struct 关键字）。C 是匿名结构体（无标签）。

正确答案: B

选择题 9

在 x86-64 上，struct { int a; } s; 的 &s.a 与 &s 的关系是？

A. &s.a > &s

B. &s.a == &s

C. &s.a < &s

D. 不确定

点击查看答案解析: C 标准规定，指向结构体的指针和其第一个成员的指针在数值上相等（interconvertible）。a 是第一个成员（offset 0），所以 &s.a == (int*)&s。

正确答案: B

选择题 10

汇编访问 ptr->member（offset = 8）最可能的指令是？

A. mov (%rdi), %eax

B. mov 8(%rdi), %eax

C. lea 8(%rdi), %eax

D. add $8, %rdi

点击查看答案解析: 8(%rdi) 是"基址 + 偏移 8"的寻址模式，直接访问 rdi + 8 处的内存，等价于 ptr->member（偏移 8 字节的成员）。A 是访问 offset 0（第一个成员），C 是加载地址而非值，D 是修改指针而非访问值。

正确答案: B

动手练习题

练习题 1：学生成绩管理系统

难度: 简单

定义一个 Student 结构体（姓名、学号、3 门课成绩），实现：

输入 5 名学生的信息

计算每个学生的总分和平均分

按总分降序排序（需要交换整个结构体）

用表格形式对齐输出（使用宽度格式化）

力扣练习：力扣数组题

练习题 2：联合体端序检测

难度: 简单

使用 union 编写程序检测：

你的系统是大端还是小端

float 和 int 的位模式对比

用 union 实现一个简单的类型转换器（int ↔ float ↔ 4 个 unsigned char）

力扣练习：力扣数组比较题

练习题 3：内存对齐实验

难度: 简单

定义多个包含不同类型成员的结构体，用 sizeof 和 offsetof 观察：

相同成员、不同顺序的结构体大小差异

_Alignas 对结构体大小的影响

#pragma pack(1) 对结构体大小的影响

绘制每个结构体的内存布局图（ASCII 图）

练习题 4：位域实现 IPv4 包头解析

难度: 简单

用位域结构体实现一个简化的 IPv4 数据包头解析器：

用位域定义 IPv4 包头结构（版本、IHL、DSCP、ECN、总长度、TTL、协议等字段）

从原始字节序列中解析出包头（使用 union 将字节数组映射为结构体）

打印每个字段的值

观察大端和小端下的差异

力扣练习：力扣位操作题

练习题 5：变体标签结构体

难度: 简单

用 enum + union 实现一个简单的变体类型系统：

定义一个 Value 结构体，包含一个 enum 类型标签和一个 union

支持 int、double、char* 三种类型

实现 print_value() 函数打印任意类型的值

实现 Value add(Value a, Value b) 在类型匹配时执行加法

类型不匹配时通过标签进行错误处理

参考 CPP教程: struct结构体了解 C++ 中 std::variant 的类型安全变体机制。

RootStack

探索

10_结构体与联合体

结构体与联合体 (Structs, Unions & Enums)

章节概述

第一节：结构体定义与使用

1.1 struct 的基本语法

1.2 指向结构体的指针（箭头运算符）

1.3 结构体数组

小节练习

第二节：typedef 与结构体

2.1 typedef 的基本用法

2.2 链表节点 —— typedef + 自引用结构体

小节练习

第三节：内存对齐与填充（Memory Alignment & Padding）

3.1 什么是内存对齐

3.2 结构体填充（Padding）

3.3 内存布局可视化

3.4 手动控制对齐

小节练习

第四节：联合体（union）

4.1 union 的基本概念

4.2 union 的典型应用

小节练习

第五节：枚举（enum）与位域（bit-field）

5.1 enum 枚举类型

5.2 位域（Bit-field）

5.3 位域的局限和注意事项

小节练习

第六节：结构体在汇编层面的访问

6.1 结构体成员的汇编寻址

6.2 复杂结构体的寻址

小节练习

章节测试

一、判断题（正确选，错误选）

二、选择题（单项选择题）

动手练习题

关系图谱

目录

反向链接