【C语言进阶】自定义类型之结构体

---

前言：

 今天分享的内容是自定义类型之一的结构体。C语言本身为我们提供了一些类型，比如 int、char、float等等，我们可以利用这些类型来定义一些比较简单的事物，那如果要定义一本书呢？C语言自身提供的这些类型，好像都无法精准的帮我们定义出一本书，一本书包含：书名、作者、出版社等主要信息，只有知道了这些信息，我们才能准确的描述一本书。为此，C语言为我们提供了结构体这种自定义类型，我们可以根据自己的需求去定义结构体里的成员列表，用来描述不同类型行的事物。可见自定义类型给我们提供了无限的遐想空间，接下来就让我们一起来看看，结构体里都有哪些有趣的知识吧！

一：结构体

1.1：结构的基础知识：

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

 数组也是一些值的集合，但一个数组里面存的都是相同类型的元素

1.2：结构的声明：

struct tag//tag是标签
{
 member-list;//成员列表，可以是一个或者多个
}variable-list;//变量列表

struct stu
{
	char name[20];//名字
	int age;//年龄
	char sex[5];//性别
	char id[20];//学号
}s1,s2;//在这里创建两个struct stu类型的结构体变量，注意结尾的分号
//这里的s1和s2是全局变量

int main()
{
	struct stu s3, s4;//这里的s3和s4是局部变量
	return 0;
}

对结构体类型进行重命名：

 把结构体类型struct stu重新命名成stu，以后就可以直接用stu来定义变量

typedef struct stu
{
	char name[20];//名字
	int age;//年龄
	char sex[5];//性别
	char id[20];//学号
} stu;//这里的stu表示类型
//把结构体类型struct stu重新命名成stu

//typedef struct stu stu;//第二种重命名方式

int main()
{
	stu s3, s4;//直接利用stu来定义变量
	return 0;
}

1.3：特殊声明（匿名结构体）：

struct
{
	char name[20];//名字
	int age;//年龄
}s1;//s1只能在这里定义

int main()
{
	return 0;
}

 上面的结构在声明的时候省略掉了结构体标签（tag），这种类型的结构体变量只能紧跟着结构体的声明去定义，匿名结构体类型只能在声明的时候用一次

struct
{
	int a;
	char b;
	float c;
}x;
struct
{
	int a;
	char b;
	float c;
} * p;

int main()
{
	p = &x;
	return 0;
}

 上面这段代码中声明了两个匿名结构体类型，在第一个匿名结构体的声明后面定义了一个x，在第二个匿名结构体变量的声明后面定义了一个指针p，在主函数里面取x的地址放到p里面，这样写可以吗？答案是不可以。虽然这两个匿名结构体的成员一模一样，但是由于匿名结构体只能用一次，所以编译器会把上面的两个声明当成完全不同的两个类型。在编译的时候就会报警告。

1.4：结构的自引用：

 在结构中包含一个类型为该结构本身的成员是否可以呢？就像下面这样：

//代码1
struct Node
{
 int data;
 struct Node next;
};

 答案是不可以，因为这里的next是一个同类型的结构体变量，那next里面又有一个next，就这样一直无限套娃套下去，自然是不可以的，所以这样肯定不能叫做结构体的自引用，正确的自引用应该像下面这样：

struct Node
{
	int data;
	struct Node* next;//结构体的声明里面包含一个同类型的结构体指针
};

自引用时需注意！！

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

 如上代码中的自引用是错误的，这里利用typedef把结构体重命名成Node，然后在结构体的成员列表里利用Node来定义一个指针变量，这样是行不通，因为程序在编译的时候都还没走到重命名的Node，就在成员列表里面遇见了Node，此时编译器就无法得知这里的Node到底是什么。下面这样写是正确的

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

}Node;

1.5：结构体变量的定义和初始化：

声明类型的同时定义变量

struct Point
{
 int x;
 int y;
}p1; //声明类型的同时定义变量p1

单独利用类型来定义变量

struct Point
{
	int x;
	int y;
};//先声明一个结构体

struct Point p2; //定义一个全局的结构体变量p2

int main()
{
	struct Point p3;//定义一个局部的结构体变量p3
	return 0;
}

结构体变量的初始化

struct Point
{
	int x;
	int y;
}p1={0,0};

struct Point p2 = {1,2}; //初始化

int main()
{
	struct Point p3 = {3,4};//初始化
	return 0;
}

结构体嵌套结构体的初始化

struct Point
{
	int x;
	int y;
}p1={0,0};

struct Point p2 = {1,2}; //初始化

struct S
{
	int num;
	char ch;
	struct Point p;//嵌套一个struct Point类型的结构体p
	float d;
};

int main()
{
	struct Point p3 = {3,4};//初始化
	struct S s = { 20,'w',{1,2},3.14f };//结构体嵌套结构体的初始化
	struct S s2 = { .ch = 'w',.d = 3.14f,.num = 20,.p.x = 1,.p.y = 2 };//乱序初始化
	printf("%d %c %d %d %f\n", s.num, s.ch, s.p.x, s.p.y, s.d);//打印s
	printf("%d %c %d %d %f\n", s2.num, s2.ch, s2.p.x, s2.p.y, s2.d);//打印s2
	return 0;
}

1.6：结构体的内存对其：

 先上例子：下面声明了两个结构体类型，分别是struct S1和struct S2，它们的成员列表都定义了两个char型变量和一个整型变量，只是定义的先后顺序有所不同，接下来我们来计算这两个结构体类型的大小（单位是字节），大家猜猜，这两个结构体的大小是多少？他俩的大小相等嘛？

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

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

int main()
{
	printf("%d\n", sizeof(struct S1));
	printf("%d\n", sizeof(struct S2));
	return 0;
}
//结果：
12
8

 这里计算结果显示struct S1的大小是12个字节，而struct S2的结果是8个字节，为什么是这样的结果呢？这就涉及到结构体内存对齐的知识了。

对齐规则

• 第一个成员在结构体变量偏移量为0的位置
• 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
• 对齐数=编译器默认的一个对齐数与该成员自身大小的较小值
• vs中的默认对其数是8，Linux和gcc都没有默认对齐数，对齐数就是成员自身大小
• 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍
• 如果嵌套了结构体的情况，嵌套的结构体对齐到自己自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体成员中的对齐数）的整数倍
• 结构体成员中如果有数组，可以这样来理解：比如结构体中有一个int c[5];，其实这就相当于这个结构体中放了5个int型的变量。

创建一个struct s1类型的变量，探究其在内存中的存储

 这里定义了一个struct S1类型的变量s，接下来就要给这个s在内存中开辟空间。首先为结构体中的char c1开辟空间，根据对齐规则：第一个成员在结构体变量偏移量为0的位置，所以为c1开辟的空间如上图中的粉色区域。接下来为结构体中的int i开辟空间，根据对齐规则：其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。这里i是一个整型变量，它的自身大小是4个字节，当前的编译环境是vs2019，它的默认对齐数是8，取两者的较小值，即此时i变量的对齐数应该是4，偏移量为1、2、3的地址都不是这个对齐数的整数倍，所以i的地址应该从偏移量为4的地址处开始，向后开辟4个字节用来存放i，如上图中的紫色区域。最后为结构体中的char c2开辟空间，c2遵循的规则和i一样，c2是一个字符型变量，它的自身大小是1，默认大小是8，取两者的较小值，就是1，偏移量为8的地址是1的整数倍，所以如上图中的绿色区域就是为c2开辟的存储空间。此时已经为结构体中的所有成员都开辟了空间，此时结构体的大小是9个字节，根据规则：结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。因此，当前结构体的总大小不符合对齐规则，那就只能继续扩容，直到满足要求为止。c1的对齐数是1，i的对齐数是4，c2的对齐数是1，取对齐数最大的，也就是4，结构体的总大小就得是4的整数倍，当结构体的大小增加到12个字节的时候就满足对齐规则了。因此最终结构体变量s的大小是12个字节

创建一个struct s2类型的变量，探究其在内存中的存储

 这里就不再详细介绍struct S2 s的创建过程，大家可以试着自己分析一下，最后再结合上图看看分析出来的结果和上图是否相同。

验证偏移量：
 我们可以通过offsetof这个宏来计算结构体成员相对于结构体起始地址的偏移量，这个宏有两个参数。第一个参数是结构体的类型，第二个参数是结构体的成员名，它的返回值是一个整型也就是偏移量的值。

#include  //offsetof的头文件
struct S1
{
	char c1;
	int i;
	char c2;
};

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

int main()
{
	printf("%d\n", offsetof(struct S1, c1));
	printf("%d\n", offsetof(struct S1, i));
	printf("%d\n", offsetof(struct S1, c2));

	printf("\n");

	printf("%d\n", offsetof(struct S2, c1));
	printf("%d\n", offsetof(struct S2, c2));
	printf("%d\n", offsetof(struct S2, i));

	return 0;
}
//结果:
0
4
8

0
1
4

1.6.1：为什么存在内存对齐？

1. 平台原因（移植原因）：
    不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2. 性能原因：
    数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

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

在设计结构体的时候如何实现节省空间呢？

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

1.7：修改默认对齐数：

 通过#pragma pack()来设置默认对齐数

实际应用：

//修改默认对齐数
#pragma pack(1)//把默认对齐数设置成4
struct S1//
{
	char c1;
	int i;
	char c2;
};
#pragma pack()//恢复默认对齐数，恢复成原来的8

int main()
{
	printf("%d\n", sizeof(struct S1));
	return 0;
}
//结果：
6

为什么是6呢？

 因为此时的对齐数被修改成了1，此时对于结构体成员中的i来说，它的自身大小是4个字节，当前的默认对齐数是1，取两者的较小值，也就是1，此时i变量在内存中的地址就可以从偏移量是1的地方开始，因此最终这个结构体类型的大小变成了6个字节。可见如果把默认对齐数修改成1，那么就不存在内存对齐了，所有的结构体成员变量在内存中都是紧挨着放的。

1.8：结构体传参：

//结构体传参
struct S
{
	int data[4];
	int num;
};

//直接传结构体变量
void print1(struct S s)//实参传的是一个结构体变量，所以形参用一个对应的结构体变量来接收
{
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d ", s.data[i]);
	}
	printf("%d\n", s.num);
}
//传结构体的地址
void print2(struct S* ps)//实参传的是结构体变量的地址，所以形参用一个对应类型的结构体指针来接收
{
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("%d\n", ps->num);
}
int main()
{
	struct S s = { {1,2,3,4}, 1000 };
	print1(s);  //传结构体
	print2(&s); //传地址
	return 0;
}

 上面展示了两种结构体传参的方法，分别是传结构体变量和传结构体的地址，对于这两种传参的方法在使用的时候该如何抉择呢？
 答案是：首选传结构体的地址。原因在于，函数传参的时候是需要压栈的，会有时间和空间上的系统开销。如果传递一个较大的结构体变量，参数压栈的系统开销就会比较大，这样就会导致性能的下降。

二：位段

2.1：什么是位段？

 位段的声明和结构体的声明是比较类似的，但是有以下两个不同点：

• 位段的成员必须是int、unsigned int、signed int等整型家族的类型。（大部分平台也支持char类型。一个位段的所有成员类型一般都是相同的）
• 位段的成员名后边有一个冒号和一个数字

例如：

struct A
{
	int _a : 2;
	int _b : 5;
	int _c : 10;
	int _d : 30;
};
//这里的A就是一个位段类型

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

 上面代码中的struct A就是一个位段类型，但是当我们计算这个位段类型的大小时，得到的结果是8。这是为什么呢？按照我们一般的想法：一个int型的大小是4个字节，这里一共有四个int型，所以这个类型的大小应该是16个字节才对。那这里的8到底是怎么得来的呢？这就要利用接下来要介绍的知识“位段的内存分配”来解释了。

2.2：位段的内存分配

 首先我们需要知道，位段中的"位"指的是二进制位。int _a : 2;表示给_a变量分配2个bit位（）；int _b : 5;表示给_b变量分配5个bit位，以此类推：给_c变量分配10个bit位，给_d变量分配30个bit位。
 结构体能干什么位段就能干什么，位段只是比结构体更节省空间而已。

• 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型
• 位段的空间上是按照需要以4个字节（int）或者1个字节（char）的方式来开辟的
• 位段设计很多不确定因素，位段是不跨平台，注重可移植的程序应该避免使用位段

以上面代码中的struct A类型的位段为例，探究其在内存中的分配

 struct A的位段成员都是int型，所以会按照4个字节来开辟空间，首先开辟第一个4字节的空间（32bit），_a占用其中的两个bit位，_b占用里面的五个bit位，_c占用里面的十个bit位，此时，第一次开辟的4个字节（32bit）只剩下15bit了，而_d需要30bit，因此空间不够，需要再开辟第二个4字节空间（32bit），所以struct A这个类型的大小就是8个字节（64个bit位）。但此时就遇到一个比较尴尬的问题，_d到底会不会利用前面剩下的15个bit位呢？这个并没有定论，C语言标准也没有对此做出任何规定，不同的编译器可能会有不同的处理方法。

注意：位段成员后面的数字不得超过它自身本来的大小，例如位段成员如果是int型，那么它后面的数字就不得超过32，因为一个int型的变量它本来的大小是4个字节，就是32位bit。（这里针对的是32位机和64位机，早期的16位机，一个int型的大小是16个字节）

2.3：验证vs2019上位段的内存分配和使用

 通过调用内存调试窗口。我们发现再在vs2019这个编译器上，对于前面剩下的字节，下一个位段成员是没有再利用的。

2.4：位段的跨平台问题

• int位段被当成有符号数还是无符号数是不确定的
• 位段中最大位的数目不能确定。（比如 int 型在16位机器中最大只有16bit，在32和64位机器上最大有64bit）
• 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义
• 当一个结构体包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的 bit 位时，是舍弃剩余的位还是利用，这也是不确定的

2.5：位段的应用

 位段会被应用在网络数据传输中，它可以有效缓解网络“拥堵”。

---

总结：
 今天，我们从结构体的一般声明开始，了解了一种特殊的声明（匿名结构体），学习了结构体变量的定义和初始化，探究了结构体的内存对齐，并介绍了修改默认对齐数方法，最后介绍了一种特殊的结构体——位段，它的最大优点是比普通的结构体更加节省空间。
 以上的内容如果对你有帮助的话，可以动动小手点赞、评论、收藏，你的支持就是我前进路上最大的动力！

---