C语言三种自定义类型：结构体，枚举，联合

一.结构体

//结构体的关键字是struct

1.结构体的声明

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

struct tag
{
member-list；//成员列表
}variable-list;  //变量列表

例:

struct stu
{
char name[20];
int age;
doublr score;
}s1,s2,s3;

1.3特殊的声明（可以不完全声明）
//匿名结构体如果成员类型都一样，在编译器看来它们的类型也不一样

struct//匿名结构体（在这里只能用一次）
{
char name[20];
float price;
char id[12];
}ss;

2.结构体的自引用

//单个结构体分为数据域和指针域
结构体中包含一个同类型的结构体
链表实现

struct Node
{
int data;  //数据
struct Node* next;  //指针
}；


typedef struct Node
{
int data;
struct Node* next;
}Node;//typedef类型重命名，将stuct Node重命名为Node

struct Node{
struct book b;
struct Node* next;};
struct Node n={{" tanggejava",66.8,"TG001"},NULL};    //:嵌套结构体初始化

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

3.1结构体变量的定义

typedef struct stu
{
char name[20];
int age;
}stu;

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

int main()
{
//stu s1;
//struct stu s1;
return 0;
}

这里我们直接定义一个结构体类型，然后通过类型定义变量

struct stu
{
char name[20];
int age;
}t1,t2;
struct 
{
char name[20];
int age;
}stu1;

这里我们直接定义结构体和结构体变量，但是后面的结构体变量是匿名定义的，因此除了已经定义的变量，无法通过该结构体定义其他变量。

3.2结构体变量的初始化：

typedef struct stu
{
char name[20];
int age;
}stu;
int main()
{
stu s1={"zhangsan",18};
return 0;
}

定义结构体变量时直接初始化

struct stu
{
char name[20];
int age;
}t1={"zhangsan",18},t2={"lisi",20};
struct 
{
char name[20];
int age;
}stu1={"xiaoming",19};

直接定义结构体变量并且初始化，但应用较少

4.结构体内对齐：

深入讨论问题：结构体大小的计算

struct s1
{
char c1;
int i;
char c2;
};
上面这个结构体占用十二个内存字节
struct s2
{
char c1;
char c2;
int  i;
};

上面这个结构体占用八个内存字节

4.1 如何计算结构体大小？

首先要掌握结构体的对其规则：
//vs编译器的默认对齐数是8，Linux环境没有默认对齐数，自身大小就是它的对齐数。
1.第一个成员在结构体变量偏移量为0的地址处。
2.其他成员要对齐到某个数字（对齐数）的整数倍处。
对齐数是编译器默认的对齐数和该成员大小的较小值。
3.结构体总大小为最大对齐数（每个成员都有一个对齐数)的整数倍。
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己最大对齐数的整数倍处，结构体的整体大小就是左右最大对齐数的整数倍。
//offsetof - 宏
//计算结构体成员相对于起始位置的偏移量。也就相当于计算初始位置的对齐数。
//size_t offsetof(structName , memberName) ： 需要索引头文件#include<stddef.h>无符号数可以用百分号u进行打印

4.2 为什么存在内存对齐：

1.平台原因（移植原因）：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常、
2.性能原因：
数据结构（尤其是栈）应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要做两次内存访问；而对齐的内存访问仅需要一次访问。
总体来说：
结构体的内存对齐是拿空间来换时间的做法。
//32位机器读取一次可以读取32个比特位也就是4个字节。
那在设计结构体时，我们既要满足对齐，又要节省空间，做法就是：
让占用空间小的成员尽量集中在一起。

4.3：如何修改默认对齐数

struct S
{
char c;
double d;
};
int main()
{
struct S s;
return 0;
}

修改方法：#pragma pack(4)…#pragma pack()将结构体夹在中间，使用过后修改回来。

5.结构体实现位段：

5.1 什么是位段：

位段的声明和结构体是类似的，但有两个不同：
1.位段的成员必须是int , unsigned int , signed int。
2.位段的成员名后面必须有一个冒号和一个数字。
ex:
struct A
{
int _a : 2; //数字代表所占内存的比特位。
int _b : 5; //该成员仅仅占有5个比特位。
int _c : 10;
int _d : 30;
}; // 所需空间小，例如这个位段仅需两个字节,可以节省空间。

5.2位段的内存分配：

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

5.3位段的跨平台问题

1.int位段被当成有符号数还是无符号数是不确定的。
2.位段中最大的数目不能确定（16位机器最大16，32和64位机器，位段最大为32个比特位）
3.位段中的成员在内存中从左向右还是从右向左分配尚未定义。
4.当一个结构体包含两个位段，第二个位段成员比较大，无法容纳第一个位段剩余的位时，时舍弃剩余的位还是利用，这是不确定的。
总结：跟结构相比，位段可以达到同样的效果，而且可以很好的节约空间，但是位段有跨平台问题的存在。

3.枚举

//枚举的关键字是enum
枚举就是把可能的取值一一列举

3.1枚举类型的定义：

enum sex
{
male,
female,
secret
};

枚举在定义的时候可以赋初值，但是枚举常量的值在主函数中不可以被改变。

enum color
{
	red,
	blue,
	green=4,
	yellow,
};

yellow的值为5

3.2枚举的优点：

//text.c -> 预编译 -> 编译 ->链接 ->text.exe 。
1.增加代码的可读性和可维护性。
2.和#define定义的标识符比较枚举有类型检查，更加严谨。
3.防止了命名污染（封装）。
4.便于调试。
5.使用方便，一次可以定义多个常量。

3.3枚举的使用：

//只能拿枚举常量给枚举常量赋值，才不会出现类型的差异
枚举常用于switch case语句判断用户输入,例如如下部分通讯录判断用户操作：

enum Option//利用枚举体优化输入方式
{
	EXIT,
	ADD,
	DEL,
	SEARCH,
	MODIFY,
	SORT,
	PRINT
};
void test()//主体实现函数
{
	int input=0;
	//创建通讯录
	Contact con;//通讯录
	InitContact(&con);//初始化通讯录
	do
	{
		 menu();
		 printf("请选择:>");
		 scanf("%d", &input);
		 switch(input)
		 {
		 	case ADD:
		 		AddContact(&con);
		 		break;
			case DEL:
				DelContact(&con);
				break;
			case SEARCH:
				SearchContact(&con);
				break;
			case MODIFY:
				ModifyContact(&con);
				break;
			case SORT:
				SortContact(&con);
				break;
			case PRINT:
				PrintContact(&con);
				break;
			case EXIT:
				printf("退出通讯录\n");
				break;
			default:
				printf("选择错误\n");
				break;
		 }
	}while(input);
}

4.联合（共用体）

//联合的关键字是union

4.1联合类型的定义：

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

union Un
{
char c;
int i;
};
int main()
{
union u;
printf("%d\n",sizeof(union））；
printf("%p\n",&u);
printf("%p\n",&(u.c));
printf("%p\n",&(u.i));
return 0;
}

可以发现三者的地址相同，联合体成员公用一块地址。
联合体的成员在同一时间只使用一个，不同时使用。

4.2联合的特点：

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

4.3联合体的运用:

联合体使用示例：判断当前编译器的大小端

int check_sys()
{
union Un
{
char c;
int i;
}u;
u.1 = 1;
return u.c;
}
int main()
{
if(1 == check_sys())
printf("小端存储\n");
else
printf(大端存储\n");
return 0;
}

联合体也存在对齐：

union Un
{
char arr[5];
int i;
};

sizeof(Un) 其实为8;
联合体总大小应该为最大对齐数的整数倍(不一定是最大成员的大小)
试计算 :

union U2
{
short c[7];
int i;
};
printf("%d\n" , sizeof(U2));

（大小为16个字节）