C语言结构体与位段详解：声明、对齐、传参及位段应用

心仪久了会沦陷2026-06-22 8:51

「 每日一句 · Daily Quote 」

"知人者智，自知者明。胜人者有力，自胜者强。"

--- 老子

文章目录

  • 前言
  • 一、结构体类型的声明
    • [1.1 结构体概念](#1.1 结构体概念)
      • [1.1.1 结构体的声明](#1.1.1 结构体的声明)
      • [1.1.2 结构体变量的创建和初始化](#1.1.2 结构体变量的创建和初始化)
    • [1.2 结构的特殊声明](#1.2 结构的特殊声明)
    • [1.3 结构的自引用](#1.3 结构的自引用)
  • 二、结构体内存对齐
    • [2.1 对齐规则](#2.1 对齐规则)
    • [2.2 为什么存在内存对齐?](#2.2 为什么存在内存对齐?)
      • [1. 平台原因 (移植原因)](#1. 平台原因 (移植原因))
      • [2. 性能原因](#2. 性能原因)
      • [2.3 修改默认对齐数](#2.3 修改默认对齐数)
  • 三、结构体传参
  • 四、结构体实现位段
    • [4.1 什么是位段](#4.1 什么是位段)
    • [4.2 位段的内存分配](#4.2 位段的内存分配)
    • [4.3 位段的跨平台问题](#4.3 位段的跨平台问题)
    • [4.4 位段的应用](#4.4 位段的应用)
    • [4.5 位段使用的注意事项](#4.5 位段使用的注意事项)
  • 总结

前言

结构体是C语言中实现自定义数据类型的重要工具，能够将不同类型的变量组合成一个整体。本文将从结构体的基本声明与初始化入手，介绍匿名结构体、自引用等特殊声明方式，深入剖析结构体内存对齐的规则与意义，对比传值与传址调用的效率差异，最后讲解位段的语法、内存分配及跨平台问题。掌握这些内容，你就能更灵活高效地组织和管理复杂数据。

一、结构体类型的声明

前面我们在学习操作符的时候,已经了解到一些结构体相关的知识,这里我们来稍微复习并进行进一步学习

1.1 结构体概念

结构体是⼀些值的集合，这些值称为成员变量。结构体的每个成员可以是不同类型的变量。

1.1.1 结构体的声明

c 复制代码 
struct tag
{
    member-list;
}variable-list;
  • struct: 关键字，用于声明结构体类型。
  • tag: 结构体标签，它是这个结构体类型的标识符，方便后续定义该类型的变量
  • member-list: 成员列表，也就是结构体中包含的各个变量
  • variable-list: 变量列表（可选），如果你在这里直接写变量名，等于在定义结构体类型的同时，直接创建了该类型的变量。

示例

c 复制代码 
struct Stu
{
    char name[20]; //名字
    int age;       //年龄
    char sex[5];   //性别
    char id[20];   //学号
}; //分号不能丢

1.1.2 结构体变量的创建和初始化

c 复制代码 
#include <stdio.h>
#include <string.h> // 使用 strcpy 必须包含此头文件

struct Stu {
    char name[20];
    int age;
    char sex[5];
    char id[20];
};

int main() {
    // 1. 结构体初始化
    struct Stu s = {"zhangsan", 20, "nan", "20230101"};
    printf("%s %d %s %s\n", s.name, s.age, s.sex, s.id);

    // 2. 修改结构体成员
    // 注意：name 和 id 是数组，不能直接使用 '=' 赋值，需要用 strcpy
    strcpy(s.name, "lisi");
    strcpy(s.id, "20230102");
    
    printf("%s %d %s %s\n", s.name, s.age, s.sex, s.id);
    
    return 0;
}

1.2 结构的特殊声明

在声明结构的时候，可以不完全的声明。

比如:

c 复制代码 
// 匿名结构体定义 1
struct {
    int a;
    char b;
    float c;
} x;

// 匿名结构体定义 2
struct {
    int a;
    char b;
    float c;
} a[20], *p;

上面的两个结构体在声明的时候省略掉了结构体标签（tag）。

那么问题来了？

在上面代码的基础上,下面的代码合法吗

c 复制代码 
p = &x; //?

警告

编译器会把上面的两个声明当成完全不同的两个类型，所以是非法的。

匿名的结构体类型，如果没有对结构体类型重命名的话，基本上只能使用一次。

在编写代码时，除非你是为了某种极其特殊的"语法练习"或者极其短小的内部辅助，否则永远给你的结构体起个名字

1.3 结构的自引用

在结构中包含⼀个类型为该结构本⾝的成员是否可以呢？

比如，定义一个链表的节点：

c 复制代码 
struct Node
{
    int data;
    struct Node next; 
};

上述代码对吗?

不对 ! 因为⼀个结构体中再包含⼀个同类型的结构体变量,在结构体内部直接包含自己，会导致无限递归定义,这样结构体变量的大小就会无穷的大，是不合理的。

正确的自引用方式：

c 复制代码 
struct Node
{
    int data;
    struct Node* next; // 正确：包含的是结构体指针，指针大小固定
};

此时结构体大小就可以计算了,因为指针的本质是一个内存地址。在 32 位系统下，它永远是 4 字节；在 64 位系统下，它永远是 8 字节。通过这个指针，我们可以把一个个独立的节点像"接龙"一样串联起来，形成了我们常说的链表。

在结构体自引用使用的过程中，夹杂了typedef对匿名结构体类型重命名，也容易引入问题.

这里先介绍一下typedef和普通结构体命名的区别

  • 普通的命名 (struct Node)
    这是在声明一个结构体类型。在后续代码中定义变量时，必须带上struct这个词。
c 复制代码 
struct Node { int data; }; // 定义类型

struct Node n1;  // 正确：必须写 struct
Node n2;      // 错误：编译器不认识没有 struct 前缀的 Node
  • 使用 typedef 命名 (typedef struct Node Node)
    这是在创建一个别名。编译器会把Node当作 struct Node 的"绰号"。你可以省略struct关键字。
c 复制代码 
typedef struct Node { int data; } Node; // 定义并起别名

Node n1;         // 正确：用绰号直接定义
struct Node n2;  // 也正确：原名依然有效

现在我们知道了typedef在结构体的相关使用方法,我们看看下面的代码，看看哪里有问题？

c 复制代码 
typedef struct {
    int data;
    Node* next;  // <--- 编译器报错就在这里！
} Node;

问题很明显：Node 是对前面匿名结构体类型进行重命名得到的别名，但如果在匿名结构体内部就提前使用 Node 来声明成员变量，这是不行的，因为此时结构体的大括号 { } 尚未闭合，Node 这个名字还没有正式生效。

解决方法如下:定义结构体时不要使用匿名结构体

c 复制代码 
typedef struct Node
{
    int data;
    struct Node* next; 
} Node;

二、结构体内存对齐

我们已经掌握了结构体的基本使用了。

现在我们深入讨论一个问题：计算结构体的大小。

这也是⼀个特别热门的考点： 结构体内存对齐

2.1 对齐规则

    1. 结构体的第一个成员对齐到和结构体变量起始位置偏移量为0的地址处
    1. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
      对齐数 = 编译器默认的一个对齐数与该成员变量大小的较小值。
      默认对齐数: VS 中默认的值为 8,Linux中gcc没有默认对齐数，对齐数就是成员自身的大小
    1. 结构体总大小为最大对齐数 的整数倍。（结构体中每个成员变量都有一个对齐数，最大对齐数是所有对齐数中最大的那个）
    1. 如果嵌套了结构体的情况，嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体中成员的对齐数）的整数倍。

2.2 为什么存在内存对齐?

1. 平台原因 (移植原因)

不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。

2. 性能原因

数据结构(尤其是栈)应该尽可能地在自然边界上对齐。 原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。假设⼀个处理器总是从内存中取8个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对齐成8的倍数，那么就可以用一个内存操作来读或者写值了。否则，我们可能需要执行两次内存访问，因为对象可能被分放在两个8字节内存块中。

总体来说 ：结构体的内存对齐是拿空间 来换取时间的做法。

那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：

让占用空间小的成员尽量集中在一起

比如:

c 复制代码 
// 例如：
struct S1
{
    char c1;
    int i;
    char c2;
};

struct S2
{
    char c1;
    char c2;
    int i;
};

S1 和 S2 类型的成员⼀模⼀样，但是 S1 和 S2 所占空间的大小有了一些区别。

在定义结构体时，尽量将成员按照类型大小"从大到小"或者"从小到大"进行分类排列

2.3 修改默认对齐数

#pragma 这个预处理指令，可以改变编译器的默认对齐数。

c 复制代码 
#include <stdio.h>

#pragma pack(1)//设置默认对齐数为1
struct S
{
    char c1;
    int i;
    char c2;
};
#pragma pack()//取消设置的对齐数，还原为默认

int main()
{
    //输出的结果是什么？
    printf("%d\n", sizeof(struct S));
    return 0;
}

答案是: 6

至于计算过程,就留给聪明的你吧(～￣▽￣)～

总之,结构体在对齐方式不合适的时候，我们可以自己更改默认对齐数。

三、结构体传参

c 复制代码 
#include <stdio.h> 

struct S {
    int data[1000];
    int num;
};

struct S s = {{1, 2, 3, 4}, 1000};

// 1. 结构体传参 (传值)
void print1(struct S s) {
    printf("%d\n", s.num);
}

// 2. 结构体地址传参 (传址)
void print2(struct S* ps) {
    printf("%d\n", ps->num);
}

int main() {
    print1(s);      // 传结构体
    print2(&s);     // 传地址
    return 0;
}

上⾯的 print1 和 print2 函数哪个好些？

答案是: 首选: print2函数

原因:

    1. 函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
    1. 如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。

结论 ：结构体传参的时候，要传结构体的地址。

四、结构体实现位段

结构体讲完就得讲讲结构体实现 位段 的能力。

4.1 什么是位段

位段（bit-field）的声明语法与结构体（struct）类似，但存在以下两点关键区别：

  1. 成员类型限制 ：在C89/C90标准中，位段的成员必须是 int、unsigned int 或 signed int；而自C99标准起，允许使用其他整型类型（如 char、short、long 以及 _Bool 等）作为位段成员。

  2. 成员后带冒号和数字：每个位段成员名后面必须紧跟一个冒号和一个整数，该整数表示该成员占用的比特位数，用于精确控制其在内存中的位宽。

简单来说，位段就是为了让程序员能直接在"比特（bit）"级别上控制内存空间。

比如:

c 复制代码 
#include <stdio.h>

struct A
{
    int _a:2;  // _a 占用 2 个比特位
    int _b:5;  // _b 占用 5 个比特位
    int _c:10; // _c 占用 10 个比特位
    int _d:30; // _d 占用 30 个比特位
};

int main()
{
    printf("%d\n", sizeof(struct A)); // 输出结果是什么？
    return 0;
}

A就是⼀个位段类型。

那位段A所占内存的大小是多少？

实际上，在绝大多数常见的 64 位 Linux 环境（GCC/Clang）下，输出结果是 8。但更"刺激"的是，如果你换成 MSVC（Windows）或者调整一下编译器的对齐参数，答案可能会变成 12 甚至 16。

同一个结构体，不同平台跑出不同的大小 。 这就是 C 语言位段（Bit-field）最典型的特征：不确定性与不可移植性

4.2 位段的内存分配

  1. 位段的成员可以是 int unsigned, int signed int 或者是 char 等类型
  2. 位段的空间上是按照需要以4个字节（int）或者1个字节（char）的方式来开辟的。
  3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。
c 复制代码 
// 一个例子
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;

// 空间是如何开辟的?

4.3 位段的跨平台问题

  1. int位段被当成有符号数还是无符号数是不确定的。
  2. 位段中最大位的数目不能确定。(16位机器最大16，32位机器最大32，写成27，在16位机器会出问题。)
  3. 位段中的成员在内存中从左向右分配，还是从右向左分配，标准尚未定义。
  4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。

总结:

跟结构体相比，位段可以达到同样的效果，并且可以很好的节省空间，但是有跨平台的问题存在。

4.4 位段的应用

下图是网络协议 中，IP数据报的格式，我们可以看到其中很多的属性只需要几个bit位就能描述，这里使用位段，能够实现想要的效果，也节省了空间，这样网络传输的数据报大小也会较小一些，对网络的畅通是有帮助的。

4.5 位段使用的注意事项

位段的几个成员共有同一个字节，这样有些成员的起始位置并不是某个字节的起始位置，那么这些位置处是没有地址 的。内存中每个字节分配一个地址，一个字节内部的bit位是没有地址的

所以不能对位段的成员使用&操作符 ，这样就不能使用scanf直接给位段的成员输入值，只能是先输入放在一个变量中，然后赋值给位段的成员。

c 复制代码 
#include <stdio.h>

struct A
{
    int _a : 2;
    int _b : 5;
    int _c : 10;
    int _d : 30;
};

int main()
{
    struct A sa = {0};
    scanf("%d", &sa._b); // 这是错误的，编译器会报错

    // 正确的示范
    int b = 0;
    scanf("%d", &b);
    sa._b = b;
    
    return 0;
}

总结

以上就是本篇博客的核心内容。我们学习了结构体的基本声明、初始化及特殊声明方式（匿名结构体、自引用），重点剖析了内存对齐的规则与存在原因，并得出"传址优于传值"的结论。最后介绍了位段------通过指定成员所占比特位数来精确控制内存，虽能节省空间但存在跨平台不确定性问题。掌握结构体与位段，是迈向链表、树等高级数据结构的第一步。

热门推荐
01如何新建文件夹？ 电脑新建文件夹的4种方法022026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片03GitHub 镜像站点04AI科技热点日报 | 2026年07月01日05国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）06AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路072026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？082026 年 AI 大模型 & AI 编程工具实战全总结09幻兽帕鲁 - 服务器管理员权限与 GM 命令完全指南10微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新