C语言自定义类型详解：结构体、联合体、位段与内存对齐实战指南

引言：在C语言中，我们经常要处理一堆相关但类型不同的数据：名字、年龄、成绩、学号……如果一个个单独定义变量，代码很快就会变成一锅粥。结构体（struct）就是C语言给我们的「数据打包工具」——把相关的数据打包成一个整体，既清晰又安全。这东西看起来简单，但真正玩出花样的是它背后的内存对齐规则，几乎每次面试都会被拷问，也是你写出高效代码的关键。今天我们就彻底把结构体内存对齐这件事掰开揉碎讲透，顺便聊聊嵌套、传参这些容易踩坑的地方。

一、结构体基础回顾

先快速过一遍基础，防止有人掉队。

struct Stu {
    char name[20];
    int age;
    char sex[5];
    char id[20];
} s1, s2;  // 声明类型的同时定义变量

初始化方式有好几种：

// 经典顺序初始化
struct Stu s1 = {"张三", 20, "男", "20230101"};
// C99 指定初始化（强烈推荐，可读性爆表）
struct Stu s2 = {
    .name = "李四",
    .age  = 19,
    .sex  = "女",
    .id   = "20230102"
};

访问成员用点操作符 .，指针就用箭头 ->，这都是老生常谈了。

1.1 结构体的特殊声明（匿名结构体）

struct {
    int a;
    char b;
    float c;
} x;
struct {
    int a;
    char b;
    float c;
} a[20], *p;
// 然后问：p = &x; 合法吗？

答案是不合法，编译器会报错或警告（warning: assignment from incompatible pointer type）。 因为这两个花括号里的结构体虽然成员一模一样，但它们是完全不同的类型。编译器把每个匿名结构体都当成独一无二的新类型看待，没有结构体标签（tag），就没法知道它们是“同一种东西”。 实际项目里几乎没人这么写，原因就两个：可读性极差，谁也不知道这个类型叫啥。一旦写了多个匿名结构体，互相根本不能赋值、传参，极其容易出 bug。

struct stu {
    /* ... */
} s1, s2;  // 最多也就这样定义变量时省略tag

或者直接 typedef 起个名字。 但其实我的编译器（VS2022）并没有报错，可能有以下原因： 编译器不报错的秘密：C语言中的“无名结构体”与“兼容性”

虽然两个结构体看起来定义是一样的，但它们实际上是两种不同的类型，为什么编译器允许将一个结构体变量 x 的地址赋给一个指向另一个结构体数组的指针 p 呢？ 关键原因在于使用了“无名结构体”（Anonymous Struct）并且编译器（尤其是C语言编译器）在处理赋值操作时采取了较为宽松的兼容性检查策略。 从严格的类型系统角度来看，p（类型为 第二个无名结构体*）应该不能指向 x（类型为 第一个无名结构体）。 为什么赋值操作 p = &x; 没有警告？ 尽管它们在技术上是不同的类型，但现代C编译器（尤其是GCC/Clang等）在处理指向结构体类型的指针赋值时，会遵循一个宽松的规则，这主要归结为以下两点： A. 结构体成员的“内存兼容性” 对于两个不同的结构体类型 T1 和 T2：

• 如果它们具有完全相同的成员列表（成员名称、类型和声明顺序都一致），那么它们在内存中的布局（Layout）是完全一样的。
• 对于编译器来说，由于 &x 和 p 所指向的内存块具有相同的字节大小和内部结构，因此将一个类型的地址赋值给另一个类型的指针，不会导致运行时访问错误。

编译器通常会忽略这种类型差异，认为它们是“兼容类型”（Compatible Types），尤其是在C语言的传统中，这种结构相同的指针赋值是常见的做法。 B. void* 的隐式提升（Casting Rule） C语言中，任何指针都可以隐式转换为 void*，反之亦然。虽然你的代码没有显式使用 void*，但编译器在处理这种“结构相同但类型不同”的指针赋值时，可以将其视为一种隐式的类型兼容转换，或者说，它允许这种赋值操作，因为：

只要两个结构体的内存布局完全相同，编译器就不会报错，甚至通常不会发出警告。

总结： 编译器没有报错，是C语言在处理结构体布局相同的无名结构体指针赋值时，遵循了宽松的兼容性规则。但在实际项目开发中，强烈建议给所有结构体命名，以确保代码的类型安全和可读性。

结论：匿名结构体就是个坑，面试可能会问，实际开发别用。

1.2 结构体的自引用：正确姿势只有一种

链表节点是经典场景：

// 错误写法——会导致无限递归大小，编译都过不了
struct Node {
    int data;
    struct Node next;  // 编译器：你让我算多大？我算不出来啊！
};

正确写法只有一种------用指针（推荐）：

typedef struct Node {
    int data;
    struct Node *next;  // 指针大小固定（32位4字节、64位8字节），可以算
} Node;                 // 这样也行，struct Node* 提前声明了类型

很多人爱写成这样，结果把自己坑死：

typedef struct {
    int data;
    Node *next;  // 错误！Node 在这里还不存在
} Node;

编译器直接报 Node 未定义。 记住铁律：自引用必须用 struct Node*，不能直接写结构体变量。

为什么很多人掉坑里？因为他们把自引用和自包含混淆了。 自包含（包含自身变量）是无限大，永远错；自引用（包含自身指针）是固定大小，完全正确，是链表的基石。

二、结构体内存对齐：性能与空间的博弈

很多人第一次看到 sizeof(struct) 的结果都会一脸懵逼：

struct S1 {
    char c1;  // 1字节
    int i;   // 4字节
    char c2;  // 1字节
};
printf("%d\n", sizeof(struct S1));  // 输出12？？？

明明 1+4+1=6，怎么就变成12了？这就涉及到内存对齐。

2.1 对齐规则

VS环境下默认对齐数8，Linux/gcc是对齐数取成员自身大小

在C语言结构体内存对齐的世界里，默认对齐数（alignment）是编译器预设的规则，通常是8（VS）或成员自身大小（gcc/Linux）。但有时我们需要手动干预，比如为了节省空间、匹配特定数据格式（如网络协议或二进制文件），或者跨平台兼容。这时候，#pragma pack 指令就派上用场了。但也提醒大家：这东西是双刃剑，用错会带来跨平台噩梦。

1. 第一个成员永远放在偏移0处。
2. 后续成员必须放在偏移是「自己的对齐数」整数倍的位置。
   • 对齐数 = min(编译器默认对齐数, 成员自身大小)
   • VS 默认是8，所以 char→1, short→2, int/double→4/8 取较小值
3. 整个结构体总大小必须是「最大对齐数」的整数倍，不够就补齐。
4. 嵌套结构体时，嵌套的结构体整体要按它内部的最大对齐数对齐。

我们用个经典例子来感受一下规则的威力：

struct S1 { char c1; int i;   char c2; };  // 12字节
struct S2 { char c1; char c2; int i; };  // 8字节

来看S1为什么是12字节（VS）：

• c1 放在 0
• i 是int，对齐数4，必须放在4的倍数地址 → 偏移0~3补3字节空洞， i 放在 4~7
• c2 放在 8
• 最大对齐数是4（int），当前大小9 → 补到12（4的倍数）

在这里插入图片描述

如果把两个char放一起（S2）就只浪费4字节，总共8字节，空间利用率大幅提升。

在这里插入图片描述

这就是经典的「把小成员尽量靠前或集中在一起」节省空间技巧。

2.2 为什么需要对齐

你可以把CPU想象成一个强迫症患者，它最喜欢一次性读8字节（64位机器）。如果一个int跨在两个8字节边界上（比如从地址1开始），CPU就得读两次内存、移位、再拼接，性能直接往下降。对齐就是用一点空间换取大幅性能提升，现代编译器默认都这么干。

三、联合体（Union）：共用内存的节省空间高手

在C语言自定义类型中，联合体（union）是一个特别的存在。它不像结构体（struct）那样每个成员各占空间，而是让所有成员共享同一块内存。这意味着联合体的大小等于其最大成员的大小，能极大节省内存，尤其适合那些“互斥”数据的场景，比如网络协议、变体类型或判断机器字节序。今天我们就来彻底拆解联合体，从声明、特点、内存计算，到实际应用和练习，一步步讲清楚。作为一个老C程序员，我会用通俗的比喻和代码例子，让你不光会用，还懂为什么用。

3.1 联合体的声明：简单，但有玄机

联合体的声明和结构体很像，但关键词是union。成员可以是不同类型，但编译器只分配足够容纳最大成员的内存。

// 联合体声明
union Un {
    char c;  // 1字节
    int i;   // 4字节
};

这里，un的大小是4字节，而不是1+4=5。因为所有成员共用同一地址。你可以把联合体想象成一个变形金刚：同一块内存，根据你访问的成员变形成不同类型。

3.2 联合体的核心特点：共享内存，修改即影响全体

联合体的成员共享内存，所以给一个成员赋值，会影响其他成员的值。这是因为它们重叠在同一地址上。来看代码例子：

int main() 
{
    union Un un = {0};
    printf("%p\n", &un);     // 三个地址相同
    printf("%p\n", &(un.c));
    printf("%p\n", &(un.i));
    return 0;
}

这里打印出所有结构体成员的地址看一下是否是这样。

在这里插入图片描述

输出三个相同的地址，证明它们共用内存。 再看修改效果：

int main() 
{
    union Un un = {0};
    un.i = 0x11223344;  // 先赋给int
    un.c = 0x55;        // 改低字节的char
    printf("%x\n", un.i);  // 输出11223355，低字节被改了
    return 0;
}

在这里插入图片描述

为什么？因为在小端字节序机器，int的低字节就是char的位置。改c就把i的低8位覆盖了。这就是共享的副作用，但也正是它的强大之处。

对比结构体：

• 结构体：成员独立，sizeof是成员总和（加对齐）。
• 联合体：成员共享，sizeof是最大成员（加对齐）。

内存布局图（假设小端）：

• 结构体：char (1字节) + 填充(3) + int (4) + char (1) + 填充(3) = 12字节
• 联合体：4字节，char占低1字节，int占全4字节

3.3 联合体大小的计算：不止最大成员那么简单

规则：

• 至少是最大成员的大小。
• 如果最大成员大小不是最大对齐数的整数倍，要补齐到整数倍。

union Un1 {
    char c[5];  // 5字节，对齐1
    int i;      // 4字节，对齐4
};
// 大小：max(5,4)=5，但最大对齐4，5不是4倍数 → 补到8字节
union Un2 {
    short c[7];  // 14字节，对齐2
    int i;       // 4字节，对齐4
};
// 大小：max(14,4)=14，最大对齐4，14不是4倍数 → 补到16字节
int main() {
    printf("%d\n", sizeof(union Un1));  // 8
    printf("%d\n", sizeof(union Un2));  // 16
    return 0;
}

在这里插入图片描述

为什么补齐？和结构体一样，为了CPU访问效率。联合体也遵守内存对齐规则。

注意事项和总结

• 优点：极致节省空间，适合互斥数据或类型歧义。
• 缺点：修改一个影响所有，要小心使用；跨平台时注意字节序。
• 与结构体的对比：结构体是“并存”，联合体是“互斥”。结合用最强。
• 开发建议：用联合体时，加类型标签（如item_type）来区分；避免复杂嵌套，保持简单。

联合体不是天天用，但用对地方，能让你的代码内存占用腰斩。

四、结构体嵌套与对齐计算（重头戏）

现在来看最容易算错的嵌套案例：

struct S3 { 
	double d; //8 8  8
	char c;   //1 8  1
	int i;    //4 8  4
};      // 先算出是16字节，最大对齐数8
struct S4 {
	char c1;      // 1字节
	struct S3 s3; // 16字节
	double d;     // 8字节
};	
// 输出多少？32！
printf("%d\n", sizeof(struct S4));  

我们一步步手绘内存布局，这是S3应该有的对齐布局，要把它嵌套在别的结构体中，只需要知道它的空间大小：16字节，最大对齐数：8。

在这里插入图片描述

偏移    内容
0       c1          ← char，放在0
1~7     填充7字节   ← 因为下一个成员是struct S3，它的最大对齐数是8，必须从8的倍数开始
8~23    s3         ← S3 本身占16字节，内部已经对齐好了
          ├ 8~15   s3.d (double)
          ├ 16      s3.c (char)
          ├ 17~19  填充3字节
          ├ 20~23  s3.i (int)
24~31   d          ← double，对齐数8，24正好是8的倍数，直接放
32      结束

在这里插入图片描述

最终大小32字节，最大对齐数是8（double），32正好是其倍数。 很多人会错算成24字节（1+16+8=25→补到32？），但嵌套结构体必须按它自己的最大对齐数对齐，所以要在c1后面补7字节。 记住一句话：嵌套结构体就像一个黑盒子，它会强行要求从自己的最大对齐数倍数地址开始摆放。

五、结构体传参的技巧

void print(struct S s);   // 传值 —— 结构体太大时性能灾难
void print(struct S *s);  // 传地址 —— 推荐！

大结构体传值时，编译器会把整个结构体压栈拷贝一份，1000个int的数组？直接拷贝4KB，慢得一批。 传地址只传8字节（64位），性能差距巨大。实际开发中，结构体参数一律传指针，除非结构体真的很小（≤16字节左右），最好还是传指针吧。

六、位段（Bit Field）

位段（bit field，也叫位域）是C语言中结构体的一种特殊用法，能让你在比特级别控制内存分配，特别适合嵌入式、网络协议或任何需要挤压空间的场景。但也有不少坑——比如跨平台不一致。用通俗比喻：位段就像把一个字节切成小块pizza，每个成员只拿自己那份，省空间但容易“切歪”。

6.1 位段的声明：简单，但类型有限制

位段的声明和普通结构体类似，但成员后面加冒号和数字，表示这个成员占多少比特（bit）。 规则：

• 成员类型必须是整数类型：int、unsigned int、signed int（C99后可扩展到其他如char、short）。
• 冒号后的数字是比特宽度，不能超过类型大小（比如int通常32bit，不能写33）。
• 位段不能是数组或指针。

6.2 位段的内存分配：打包

位段不是简单相加大小，compiler 会按需打包：

1. 成员类型决定单位：如果用int，位段按4字节（32bit）单元打包；用char，按1字节。
2. 空间开辟方式：从低位到高位（或相反），不够一个单元就新开一个。
3. 不确定因素多：比特顺序（left-to-right or right-to-left）、填充、跨单元时是否浪费，都不标准。

struct A 
{
    int _a : 2;   // 占2bit
    int _b : 5;   // 占5bit
    int _c : 10;  // 占10bit
    int _d : 30;  // 占30bit
};
printf("%zu\n", sizeof(struct A));  // 通常8字节（2个int）

这里总比特47（2+5+10+30），超过32bit，六个字节刚好只比它多一位，所以大小是6字节，这对吗？看结果：

在这里插入图片描述

这里给出内存中存值的图解，为便于查看，使用下述示例：

struct S {
    char a : 3;
    char b : 4;
    char c : 5;
    char d : 4;
};
struct S s = {0};
s.a = 10;
s.b = 12;
s.c = 3;
s.d = 4;

在这里插入图片描述

可以得知，当前编译器为right-to-left,当剩余位数不够时会新开一个字节。

• a:3bit → 占字节0的低3bit
• b:4bit → 接在a后，占字节0的4-7bit
• c:5bit → 字节0剩1bit不够，开字节1，占低5bit
• d:4bit → 接c后，占字节1的5-8bit，但char是8bit，所以可能到字节2

实际sizeof就是3字节。 对比普通结构体：位段能把47bit塞进8字节，普通struct要16字节（4 int）。

6.3 位段的跨平台问题

标准没规定细节，导致移植噩梦：

1. 符号性不确定：int位段是有符号还是无符号？compiler决定。
2. 最大宽度不确定：16位机max 16bit，32位max 32bit，写27bit在老机寄。
3. 分配方向不确定：从左到右（MSB first）还是右到左（LSB first）？
4. 跨单元处理不确定：剩余bit不够下一个成员，是浪费还是用下一个单元？

位段能省空间，但跨平台别用。可移植代码避开它，用位运算+掩码代替。 例子：假设两个位段，第二个大到剩bit放不下，是舍弃剩bit还是新单元？不确定。

6.4 位段的应用：网络协议的救星

在这里插入图片描述

位段不是天天用，但懂了能在关键时省下KB级内存。例如上述的网络协议数据报。

掌握了这些，你写出来的结构体不再是「黑盒子」，而是可以精确控制内存布局的利器——无论是省内存、提速，还是写高性能网络协议，都能得心应手。