C语言——自定义类型(结构体、枚举、联合)

0. 思维导图

1. 结构体

1.1 结构的基础知识

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

• 数组：一些值的集合，类型是相同的；
• 结构体：可是各种类型的集合。

1.2 结构的声明

struct tag//结构体标签
{
	member - list;//成员列表
}variable-list;//变量列表

例如描述一个学生：

struct Stu
{
	char name[20];//学生的名字
	int age;//学生的年龄
	char gender[5];//学生的性别
	char id[10];//学生的学号
}s1,s2;//全局变量，s1和s2是两个结构体变量

int main()
{
	struct Stu s3, s4;//局部变量
	return 0;
}

补充说明：
在这里如果想要创建结构体变量时，每次都需要写上struct，可能会稍许麻烦，所以可采样typedef进行结构体重命名。

typedef struct Stu
{
	char name[20];
	int age;
	char gender[5];
	char id[10];
}Stu;//这里是结构体类型

int main()
{
	Stu s1, s2;
	return 0;
}

1.3 特殊的声明

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

//匿名结构体类型
struct
{
 int a;
 char b;
 float c;
}x;//因为是匿名的，所以在创建的时候必须设置好变量

struct
{
 int a;
 char b;
 float c;
}a[20], *p;

上面的两个结构在声明的时候省略掉了结构体标签（tag）。
那么在上面代码的基础上，下面这段代码合法吗？

p = &x;

警告：

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

1.4 结构体的自引用

代码示例：

struct Node
{
	int datazhe;
	//struct Node next -- error
	struct Node* next;
};

注意：

typedef struct Node
{
	int data;
	Node* next;
}Node;
//这样写代码，可行否？
//在这里，给结构体重命名是在后面，而在此之前，都不认识这个名字，无法识别
//解决方案：
typedef struct Node
{
	int data;
	struct Node* next;
}Node;

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

代码示例：

struct Point
{
	int x;
	int y;
}p1;//声明结构体时定义变量p1

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

struct Point p3 = { 1,2 };//初始化：定义的的时候同时赋值

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

1.6 结构体内存对齐

有了结构体的基本知识。
现在我们升入讨论一个问题：计算结构体的大小。
结构体的内存对齐是结构体中非常重要的一个知识。

结构体的对齐规则：

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

实例演示：

struct S
{
	char a;// 1byte
	int b; // 4byte
	char c;// 1byte
};

这里我们可以用C语言中的宏——offsetof（可以求结构体中某个元素相较起始位置的偏移量）来验证。

嵌套结构体示例：

struct S1
{
	double a;
	char b;
	int c;
};
struct S2
{
	char d;
	struct S1 s1;
	double d;
};

为什么存在内存对齐

官方未给出详解解释，下面仅供参考。

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

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

总的来说就是：

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

所以我们在设计结构体的时候，尽量让空间小的成员尽量集中在一起，这就既满足对齐，又做到了空间节省。

1.7 修改默认对齐数

#pragma pack(1) //将默认对齐数设置为 1
struct S1
{
	char a;
	int b;
	char c;
};

int main()
{
	printf("%d\n", sizeof(struct S1));      //6
	printf("%zd\n", offsetof(struct S1, a));//0
	printf("%zd\n", offsetof(struct S1, b));//1
	printf("%zd\n", offsetof(struct S1, c));//5
	return 0;
}

1.8 结构体传参

struct S
{
	int data[1000];
	int num;
};
struct S s = { {1,2,3,4}, 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;
}

在这里用print2是优于print1的。

原因：
传值调用参数会压栈，重新开辟内存，对数据进行存储，另外在传递的时候也会消耗时间，如果结构体过大，那传参的压力比较大，会导致性能的下降；
传址的话，把地址传给函数，一个地址的字节为4个字节或8个字节，这时候传参的压力就会小一点。

2. 位段

关于位段的详细内容，此篇文章——C语言——位段以进行详细讲解，可点击链接跳转查看。

3. 枚举

枚举，顾名思义就是一一列举。
比如：

一周的周一到周天，可以一一列举；
一年的十二个月，可以一一列举；
二十四节气，也可也列举。

3.1 枚举类型的定义

enum Day//星期
{
	Mon,//注意，这里面的元素是以逗号隔开
	Tues,
	Wed,
	Thur,
	Fir,
	Sat,
	Sun
};

enum Color//颜色
{
	RED,
	GREEN,
	BLUE
};

enum Day、enum Color这些都是枚举类型。
{}中的类容，可以进行取值，叫做枚举常量。
如果不将其赋值，则默认从0开始，一次递增1。
如果初始化赋值，则后面也是往后一次递增1()。

3.2 枚举的优点

枚举的优点

1. 增加代码的可读性和维护性。

enum Option
{
	ADD=1,
	DEL,
	MODIFY
};
int main()
{
	int input = 0;
	scanf("%d", &input);
	//switch (input)
	//{
	//case 1:
	//	//增加元素
	//	break;
	//case 2:
	//	//删除元素
	//	break;
	//case 3:
	//	//修改元素
	//	break;
	//default:
	//	break;
	//}
	switch (input)
	{
		//通过枚举定义，则可以直接观察到我们要执行的功能
	case ADD:
		break;
	case DEL:
		break;
	case MODIFY:
		break;
	default:
		break;
	}
}

2. 和#define定义的标识符比较枚举有类型检查，更加严谨。
3. 防止了命名污染(封装)。
4. 便于调试。
5. 使用方便，一次可以定义多个变量。

3.3 枚举的使用

enum Color//颜色
{
	RED = 1,
	GREEN = 2,
	BLUE = 4
};

int main()
{
	enum Color clr = RED;
	return 0;
}

4. 联合体

4.1 联合体的类型定义

联合也是一种特殊的自定义类型。
这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间(所以联合也叫共用体)。

//联合类型的声明
union Un
{
 char c;
 int i;
};
//联合变量的定义
union Un un;
//计算连个变量的大小
printf("%d\n", sizeof(un));

4.2 联合体的特点

联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）。

union UN
{
	char a;
	int b;
};

int main()
{
	union UN un;
	printf("%d\n", sizeof(un));
	printf("%p\n", &un);
	printf("%p\n", &un.a);
	printf("%p\n", &un.b);
	return 0;
}

4.3 联合体大小的计算

• 联合的大小至少是最大成员的大小。
• 当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。