【C语言】自定义类型 - 上：结构体

---

前言

C语言提供了一些内置类型，例如char，int，float，double等，但是这些类型不一定能够完全解决问题，如果要说明一种复杂对象，单单一个char，int就不足以说明了，这时C语言就提供了一种自定义类型，比如用的最多的结构体，联合体和枚举，本文就是用来详细探究自定义类型。

---

1. 结构体

1.1 结构体类型的声明

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

//结构体关键字，结构体标签(名)
struct tag
{ 
	//结构体成员列表
	member-list;
}variable-list;
//结构体变量列表

比如说描述一个学生，学生要有姓名，年龄，性别和分数：

struct Stu
{
	char namr[20];
	int age;
	char sex[10];
	double score;
}stu1;
//stu1是根据上面的结构体类型，创建的一个结构体变量
//是一个全局变量
//分号不能丢
int main()
{
	struct Stu stu2;
	//这里的stu2是一个局部结构体变量
	return 0;
}

1.1.1 特殊的声明

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

//没有结构体标签
//这种叫做匿名结构体类型
//并且只能用一次，一次性的
struct
{
	char namr[20];
	int age;
	char sex[10];
	double score;
}stu1;
//不同的匿名结构体属于不同的类型

---

1.2 结构体的自引用

说到自引用，就不得不提到数据结构里的链表，顾名思义，链表就是像一跟链条，把数据一个个串联起来，通过数据1可以找到数据2，通过数据2可以找到数据3，以此类推。
把每个数据都当作一个结点，数据1结点包含数据2结点，那么1就可以找到2，数据2结点包含数据3结点，数据2就能找到3，有了这个概念就可以设计链表：

struct Node
{
	//每个结点都必须包含一个数值和下一个结点
	//而下一个结点自然也是struct Node类型
	int data;
	struct Node next;
};

这种设计是有问题的，并不知道该结点的大小是多少，如果用sizeof来计算大小没法算，因为该结点包含一个整形和一个下一个结点，下一个结点又包含一个整形和一个结点，无限套娃下去了。

包含结点不行，那么包含结点的地址是可以的，在一个结点中存放一个数据和下一个结点的地址，并且地址的大小是固定的：

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

这样就把一个结点拆成了两个部分，数据域和指针域，数据域用来存放数据，指针域用来存放下一个结点的地址。

该指针能自己找到与自己相同类型的一个结点，因此叫做结构体的自引用。

结构体里包含同类型的结构体是不行的，正确的写法是结构体里包含一个同类型的结构体指针。

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

有了结构体类型，定义变量和初始化就很简单了

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

struct Point p2; //定义结构体变量p2

//初始化：定义变量的同时赋初值。		
struct Point
{
 int x;
 int y; 
}p1 = {2，3};	
//在声明类型的同时定义变量再给它初始化
//需要注意的是：把p1 = {2,3}去掉，是它的类型
//类型在内存中是不会开辟空间的，只有用该类型创建变量
//才会在内存中开辟空间

struct Stu        //类型声明
{
 char name[15];//名字
 int age;      //年龄
};
struct Stu s = {"zhangsan", 20};//初始化	

struct Node
{
 int data;
 struct Point p;
 struct Node* next; 
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化

struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

---

1.4 结构体内存对齐

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

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

如何计算？
首先得掌握结构体的对齐规则：

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

画图解释：

可以使用库函数offsetof来验证分析的是否正确：

c1在0偏移量处，i在4偏移量处，c2在8偏移量处，是正确的。


S2的第一个成员c1在0偏移量处，c2在1偏移量处，i在4偏移量处，分析的也是正确的。

结构体在内存中存放会有一定的浪费，来使得在某些边界上进行内存对齐

分析以下代码：

//练习1
struct S1
{
 char c1;
 int i;
 char c2;
};
printf("%d\n", sizeof(struct S1));//12
//上面图中的例子

//练习2
struct S2
{
 char c1;
 char c2;
 int i;
};
printf("%d\n", sizeof(struct S2));//8
//上面图中的例子

//练习3
struct S3
{
 double d;
 char c;
 int i;
};
printf("%d\n", sizeof(struct S3));//16
//如果上图理解了就很好算
//double占8个字节，偏移量是7
//char占1个字节，对齐数取较小值1，放在偏移量8的位置
//8当然是1的倍数因此是可以的
//int占4个字节，对齐数取较小值4，下一个偏移量处是9
//不是4的倍数，只能浪费3个字节到偏移量12处
//此时三个成员变量全部放入内存
//从0偏移量处到15偏移量处一个共是16个字节
//而16正好是结构体成员中最大对齐数8的倍数
//所以该结构体变量占16个字节

//练习4-结构体嵌套问题
struct S4
{
 char c1;
 struct S3 s3;
 double d;
};
printf("%d\n", sizeof(struct S4));
//第一个成员总是放在0偏移量处，c1放在0处
//第二个成员是个结构体，而我们算出该结构体大小为16个字节
//此时看结构体内存对齐的规则第4条：
//嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处
//S3里的成员最大对齐数为double也就是8个字节
//因此需要对齐到8的整数倍
//前面7个字节就浪费掉了，直接对齐到偏移量第8处的地方
//因为该结构体大小为16，直接向后偏移16个字节到24偏移量处
//最后一个成员为double类型，占8个字节
//对齐数也就是8，而偏移量处24为8的倍数
//因此可以直接存放
//自此存放完毕，0偏移量处到31偏移量处一共为32个字节
//规则4还有最后一句话：
//结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
//嵌套结构体S3最大对齐数是8, S4最大对齐数也是8
//32是8的整数倍，因此结构体大小为32个字节

为什么存在内存对齐？

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

2. 性能原因：
   数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
   原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

总体来说：

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

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

让占用空间小的成员尽量集中在一起，这样在一定程度上就可以节省我们的空间

那能否修改默认对齐数呢？看下面代码：

//结果？
struct S1
{
	int i;
	double j;
}s1;
int main()
{
	printf("%d\n", sizeof(s1));
	return 0;
}

不难计算，结果为16，结构体变量的总大小是最大对齐数的倍数，最大为8，而当前偏移量为11，所以浪费4个字节到偏移量15的位置，此时从0偏移量到15偏移量共为16个字节。

这时修改默认对齐数需要用到#pargma这个预处理指令改变默认对齐数：

#pragma pack(4)	
//把默认对齐数改为4
struct S1
{
	int i;
	double j;
}s1;
#pragma pack()
//再改回原来的默认对齐数
int main()
{
	printf("%d\n", sizeof(s1));
	return 0;
}

此时默认按照4字节对齐，最大对齐数为4，而目前结构体大小为12个字节，正好是4的整数倍，因此该结构体大小为12个字节。

---

1.5 结构体传参

结构体传参有两种方式，传值调用和传址调用：

//打印结构体数据
struct S 
{
    char name[20];
    int num;
};
//结构体传参
void print1(struct S s) 
{
    printf("%s\n%d\n",s.name, s.num);
}
//结构体地址传参
void print2(struct S* ps) 
{
    printf("%s\n%d\n",ps->name, ps->num);
}
int main()
{
	struct S s = {"zhangsan", 1000};
	print1(s);  //传结构体
	print2(&s); //传地址
 return 0; 
}

上面两种方法都可以完成任务，但哪种方法更好呢？

• 第一种传值调用，把实参s传过去形参要开辟一块同样大的空间来接收s，并且也要把拷贝数据拷贝给形参，这就造成了空间和时间的双重浪费
• 第二种传址调用，传过去一个结构体的指针，指针大小只占4/8个字节，因此这种方法是优于传值调用。

结构体传参，尽量要传结构体的地址，如果不想通过指针操作结构体，只需要在前面加上const修饰。

2. 结构体实现位段

2.1 什么是位段

位段的声明和结构是类似的，有两个不同：

1. 位段的成员必须是 char、int、unsigned int 或signed int 。
2. 位段的成员名后边有一个冒号和一个数字。

比如说：

struct A
{
	int a : 2;
	int b : 5;
	int c : 10;
	int d : 30;
};

这里的A就是位段类型，位是指比特位，a：2说明a只分配两个比特位，b：5说明b只分配5个比特位等。如果有些成员的取值范围非常有限的时候，不需要32个比特位来表示，就可以使用位段来适当的减少其所占的内存空间。

不难看出，位段其实是用来节省空间的。

那么位段A的大小是多少个字节？

printf("%d\n", sizeof(struct A));

答案是8个字节，为什么呢？这就涉及到了位段在内存中的分配。

2.2 位段的内存分配

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

通过第二条规则，就可以分析出为什么是8个字节了，首先由于位段成员都是int类型，所以先开辟一个整形大小4个字节也就是32个比特位来使用，而该位段的大小一共为47个比特位，前三个成员一共占了17个比特位，还剩15个比特位，不够最后一个成员使用，因此会再次开辟4个字节供其使用，现在有两个问题：
因为第前面还剩15个比特位，这时最后一个成员会直接使用新开辟的空间还是把前面15个比特位用完再使用新的呢？
接下来介绍，但是不管怎么说，都是开辟了8个字节，所以结果为8。

探究是哪种情况？

struct S {
//首先开辟一个字节8个比特位
	//a用完后剩5个bit
	char a : 3;
	//b再用完后剩1个
	char b : 4;
//开辟第二个字节
	//第一种情况：
	//如果c把第一个字节中剩的1个bit用完后
	//再用新开辟的8个bit后，还剩4个bit
	//然后剩的4个bit正好够d使用
	//因此只需要开辟两个字节
	char c : 5;
	//第二种情况：
	//c把第一个字节剩的一位浪费掉
	//直接使用新开辟的字节
	//这时还剩3个bit
	//剩3个位不够d用
	//再开辟一个字节给d用
	//此时需要开辟的空间大小为三个字节
	char d : 4;
};

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

运行结果：

结果是3个字节，说明是第二种情况，搞清楚这个后再来探究一下数据是怎么在内存中存放的：

struct S {
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};

int main()
{
	struct S s = { 0 };
	s.a = 10; 
	s.b = 12; 
	s.c = 3; 
	s.d = 4;
	return 0;
}

调试看内存：

2.3 位段的跨平台问题

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

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