精通C语言（2.结构体）（内含彩虹）

🌈这里是say-fall分享，感兴趣欢迎三连与评论区留言
🔥专栏：《C语言入门知识点》、《C语言底层》、《精通C语言》、《C语言编程实战》
💪格言：做好你自己，你才能吸引更多人，并与他们共赢，这才是你最好的成长方式。

前言：

对于C语言的基础语法其实我们非常地了解了，但是有的时候我们还是会纠结于如何描述一些东西，比如说我要存储一本书的信息：作者、出版社、定价、出版年份等等信息，我们就需要储存一系列属性不同的信息，想要在C语言中储存这些信息就要用到结构体这个变量，与内置类型如：char、short、int、long、float、double等不同，结构体是用户自定义的，所以称为自定义类型变量，下面快做好笔记，我们一起深入了解一下结构体

文章目录

前言：
正文：
- [1. 结构体的基本使用](#1. 结构体的基本使用)
- - [1.1 结构的声明](#1.1 结构的声明)
  - - [1.1.1 一般声明](#1.1.1 一般声明)
    - [1.1.2 结构体变量的特殊声明](#1.1.2 结构体变量的特殊声明)
  - [1.2 结构体变量的创建和初始化](#1.2 结构体变量的创建和初始化)
  - - [1.2.1 结构体变量的创建](#1.2.1 结构体变量的创建)
    - [1.2.2 结构体变量的定义并且初始化](#1.2.2 结构体变量的定义并且初始化)
  - [1.3 结构的自引用](#1.3 结构的自引用)
  - [1.4 结构成员访问操作符](#1.4 结构成员访问操作符)
  - - [1.4.1 直接访问](#1.4.1 直接访问)
    - [1.4.2 间接访问](#1.4.2 间接访问)
- [2. 结构体的内存对齐](#2. 结构体的内存对齐)
- - [2.1 什么是结构体的内存对齐?](#2.1 什么是结构体的内存对齐?)
  - [2.2 为什么要内存对齐](#2.2 为什么要内存对齐)
  - [2.3 修改默认对齐数](#2.3 修改默认对齐数)
- [3. 结构体传参](#3. 结构体传参)
- [4. 结构体实现位段](#4. 结构体实现位段)
- - [4.1 什么是位段？](#4.1 什么是位段？)
  - [4.2 位段的内存占用](#4.2 位段的内存占用)
  - [4.3 位段的跨平台问题](#4.3 位段的跨平台问题)
  - [4.4 位段的注意事项](#4.4 位段的注意事项)

正文：

1. 结构体的基本使用

结构是⼀些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量，如：
标量、数组、指针，甚⾄是其他结构体。

1.1 结构的声明

1.1.1 一般声明

c 复制代码

struct tag
{
 member-list;
}variable-list;

例如要描述学生，就可以这样声明：

c 复制代码

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

1.1.2 结构体变量的特殊声明

除了上述的一般声明以外，还有特殊声明：匿名结构体类型

c 复制代码

struct
{
	int a;
	char b;
	float c;
}xx;
//定义了一个匿名结构体（没有结构体标签名），并同时创建了一个该结构体类型的变量 xx
//xx 包含三个成员：int 类型的 a、char 类型的 b、float 类型的 c

c 复制代码

struct {
    int a;
    char b;
    float c;
}a[20], *p;
//同样定义了一个匿名结构体（成员和第一个个结构体完全相同，但在 C 语言中被视为不同类型）
//同时创建了：
//结构体数组 a[20]（包含 20 个该结构体类型的元素）
//结构体指针 p（指向该结构体类型的指针）

但是值得注意的是，p = &xx;是非法的

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

匿名的结构体类型，如果没有对结构体类型重命名的话，基本上只能使⽤⼀次。
这里我们用if语句判断一下：

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

1.2.1 结构体变量的创建

直接在声明后面添加变量名可以直接定义变量：

c 复制代码

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

1.2.2 结构体变量的定义并且初始化

对于结构体变量的初始化主要有两种方法：

①按照次序依次填入
②不按照次序填入，前面要加：（.【成员变量名】）用来赋值

c 复制代码

#include <stdio.h>

struct stu
{
	char name[20];//姓名
	int age;//年纪
	char sex[5];//性别
	char id[20];//学号
};

int main()
{
	struct stu s1 = {"Tom",20,"male","02522225555"};//按照次序依次填入
	printf("%s\n",s1.name);
	printf("%d\n", s1.age);
	printf("%s\n", s1.sex);
	printf("%s\n", s1.id);
	
	struct stu s2 = { .age=20,.name = "Jerry",.sex = "male",.id="02555552222" };//不按照次序填入，前面要加（.【成员变量名】）用来赋值
	printf("%s\n", s2.name);
	printf("%d\n", s2.age);
	printf("%s\n", s2.sex);
	printf("%s\n", s2.id);
}

结构体变量也可以先定义，后来再赋值：

c 复制代码

Strcut stu s2;
struct stu s2 = { .age=20,.name = "Jerry",.sex = "male",.id="02555552222" };
printf("%s\n", s2.name);
printf("%d\n", s2.age);
printf("%s\n", s2.sex);
printf("%s\n", s2.id);

1.3 结构的自引用

下面我们看一个代码：

c 复制代码

struct test
{
	int num;
	struct test test1;
};
//这个结构体包含了自身，那么他正确吗？

答案是不正确的，因为这个结构体很类似于递归，而没有最后的返回极限，这就会导致这个结构体内存极大

那么正确的自引用是什么样子的呢？

c 复制代码

struct test
{
	int num;
	struct test* test1;
};
//如果只是在结构体类型里面放一个指向自身类型的指针的话，就不用担心内存占用了

但是还有一些操作极易在产生一些错误：

c 复制代码

typedef struct
{
 int data;
 Node* next;
}Node;
//这段代码是重定义匿名结构体的名称为Node，
//但是不难发现这个代码在未定义Node之前就在匿名结构体中就使用了这个名称

那这种情况要在怎么处理呢？

答案是不对匿名结构体重定义就好了：

c 复制代码

typedef struct Node
{
 int data;
 struct Node* next;
}Node;

1.4 结构成员访问操作符

1.4.1 直接访问

对于直接访问我们其实已经使用过了：

c 复制代码

	printf("%s\n",s1.name);
	printf("%d\n", s1.age);
	printf("%s\n", s1.sex);
	printf("%s\n", s1.id);
	//在这段代码中（【结构名】.【成员变量名】）就是直接访问的方式

访问方式：（【结构名】.【成员变量名】）

1.4.2 间接访问

有时候我们得到的不是⼀个结构体变量，⽽是得到了⼀个指向结构体的指针。如下所⽰：

c 复制代码

#include <stdio.h>
struct Point
{
	int x;
	int y;
};

int main()
{
	struct Point p = { 3, 4 };
	printf("x = %d y = %d\n", p.x,p.y);
	struct Point* ptr = &p;
	//定义一个指向struct Point类型的指针ptr，并让它指向结构体变量p的地址
	ptr->x = 10;
	ptr->y = 20;
	printf("x = %d y = %d\n", ptr->x, ptr->y);
	return 0;
}

访问方式：（【指针名】->【成员变量名】）
等价方式：先解引用指针（ptr），再用 . 运算符

2. 结构体的内存对齐

对于之前我们学过的变量来说，他们都是有其占用的内存大小的，那么对于结构体这个自定义类型变量来说，他的内存占用是多少呢？
接下来我们就来看一下结构体的内存对齐：

2.1 什么是结构体的内存对齐?

结构体的内存对齐是指编译器为结构体的成员分配内存时，遵循特定的规则调整成员的起始地址，使成员的地址能被某个 "对齐数" 整除，从而提高 CPU 访问内存的效率。这是一种 "空间换时间" 的优化策略 ------CPU 访问对齐的内存地址时速度更快，而未对齐的地址可能需要多次访问才能完成操作。
这个操作可能对于读取所有数据而言没有什么用，但是当读取单个或者几个数据的时候，就能显现出其"空间换时间"的特性了

看一下代码：

c 复制代码

#include <stdio.h>

struct test1
{
	char c1;
	int i1;
	char c2;
};

struct test2
{
	char c1;
	char c2;
	int i1;
};

int main()
{
	printf("%zd\n", sizeof(struct test1));
	printf("%zd\n", sizeof(struct test2));
	return 0;
}

运行结果：

c 复制代码

12
8

为什么会怎样呢，下面我们看一下内存中具体的表现：
看完直观的图片以后我们了解一下更具体的规则：

1.结构体的第⼀个成员对⻬到和结构体变量起始位置偏移量为0的地址处

2.其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处。

对⻬数=编译器默认的⼀个对⻬数与该成员变量⼤⼩的较⼩值。
VS 中默认的值为 8
Linux中gcc没有默认对⻬数，对⻬数就是成员⾃⾝的⼤⼩

3.结构体总⼤⼩为最⼤对⻬数（结构体中每个成员变量都有⼀个对⻬数，所有对⻬数中最⼤的）的

整数倍。

4.如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处，结构

体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍。
3正是test1后面三个比特位被浪费的原因（9、10、11）

再来两个练习：

c 复制代码

#include <stdio.h>

struct test3
{
	double d;
	char c;
	int i;
};

struct test4
{
	double d1;
	struct test3;
	int i1;
};

int main()
{
	printf("%zd\n", sizeof(struct test3));
	printf("%zd\n", sizeof(struct test4));
	return 0;
}

运行结果：

c 复制代码

16
32

2.2 为什么要内存对齐

平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
性能原因：
数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于，为了访问未对⻬的内存，处理器需要作两次内存访问；⽽对⻬的内存访问仅需要⼀次访问。假设⼀个处理器总是从内存中取8个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对⻬成8的倍数，那么就可以⽤⼀个内存操作来读或者写值了。否则，我们可能需要执⾏两次内存访问，因为对象可能被分放在两个8字节内存块中。

总体来说：结构体的内存对⻬是拿空间来换取时间的做法。
如何理解内存对齐的"空间换时间"呢？打个比方：

有n个家庭出去旅游，当他们住店的时候,如果一个家庭在一起住的话（在一个顺位读取的字节中 ），加入有消息要通知这个家庭的话，只需要找到他们住的房间就好了，而如果他们是散着住，这个孩子和另一家孩子关系好就去其他房间了（无内存对齐 ），这就需要再去另一个房间里找孩子（数据），浪费了时间

那么我们处理结构体成员变量的时候该怎么处理更好呢？

答案是将小一点的变量连续地放在一起，就像是我们刚才见到的test1和test2一样

2.3 修改默认对齐数

有的时候我们并不想用这种对其的方式来省时间，那我们也是有方法的。
#pragma 这个预处理指令，可以改变编译器的默认对⻬数。

c 复制代码

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

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

int main()
{
	printf("%zd\n", sizeof(struct test5));
	printf("%zd\n", sizeof(struct test6));
	return 0;
}

运行结果：

c 复制代码

6
6

通过这种方式我们就能忽略掉内存对齐或者是用修改对齐值的方式来做其他事情

3. 结构体传参

对于结构体传参，我们和其他变量一样，也可以以地址作为数据传参

c 复制代码

#include <stdio.h>

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

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

void print1(struct S s)
{
	printf("%d\n", s.num);
}

void print2(struct S* ps)
{
	printf("%d\n", ps->num);
}

int main()
{
	print1(s);
	print2(&s);
	return 0;
}

两种方法的效果是一样的，那么那种更好呢？

答案是以地址为数据传参的更好

函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。

如果传递⼀个结构体对象的时候，结构体过⼤，参数压栈的的系统开销⽐较⼤，所以会导致性能的下降。
什么是压栈，我们过几天详细了解

所以结构体传参的正确做法是传结构体的地址

4. 结构体实现位段

4.1 什么是位段？

既然内存对齐是一种"空间换时间"的手段，那一定就有"时间换空间"的手段

位段（Bit Field）是 C 语言中一种特殊的结构体成员定义方式，允许将数据以二进制位为单位进行存储，从而更精细地控制内存占用。它的核心作用是 "压缩存储"------ 对于只需要少数几个位就能表示的数据（如状态标志、枚举值等），可以避免使用完整的字节 / 整数类型造成的内存浪费。
基本语法：

c 复制代码

struct 结构体名 {
    类型 成员名 : 位长度;  // 位段成员，"位长度"表示该成员占用的二进制位数
    // ... 其他位段或普通成员
};

c 复制代码

struct test
{
	int a : 2;
	int b : 4;
	int c : 8;
	int d : 20;
};

int main()
{
	printf("%zd\n", sizeof(struct test));
	return 0;
}

运行结果：

c 复制代码

4.2 位段的内存占用

位段的成员可以是 int unsigned int signed int 或者是 char 等类型

位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的⽅式来开辟的。

位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使⽤位段。

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;

对于这段代码的调试如下:

我们发现在这部分存的数据是62 03 04 ，为什么会是这样，我们来看一下具体的内存

或者说，空间是如何开辟的？

我们这里以1个byte也就是8个bit开辟一块空间，由右向存储尝试，还原出了调试出来的显示

那么是不是所有的位段开辟存储规则都是这样呢？

4.3 位段的跨平台问题

int位段被当成有符号数还是⽆符号数是不确定的。

位段中最⼤位的数⽬不能确定。（16位机器最⼤16，32位机器最⼤32，写成27，在16位机器会出问题。

位段中的成员在内存中从左向右分配，还是从右向左分配，标准尚未定义。

当⼀个结构包含两个位段，第⼆个位段成员⽐较⼤，⽆法容纳于第⼀个位段剩余的位时，是舍弃剩余的位还是利⽤，这是不确定的。

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

4.4 位段的注意事项

位段的⼏个成员共有同⼀个字节，这样有些成员的起始位置并不是某个字节的起始位置，那么这些位置处是没有地址的。内存中每个字节分配⼀个地址，⼀个字节内部的bit位是没有地址的。
所以不能对位段的成员使⽤&操作符，这样就不能使⽤scanf直接给位段的成员输⼊值，只能是先输⼊放在⼀个变量中，然后赋值给位段的成员。

c 复制代码

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;
}

位段是 "以代码复杂性换取内存效率" 的取舍，适合对内存极度敏感的场景（如嵌入式开发），普通应用中较少使用。

本节完...