C语言—自定义类型（结构体、位段、枚举、联合）

一、结构体struct

1. 结构体是一些值的集合，这些值称为成员变量。每个成员可以是不同类型的变量。
2. 结构体所占内存大小为其成员所占内存之和。空结构体所占内存大小为1字节。
3. 柔性数组，结构体最后一个成员允许是未知大小的数组，用malloc函数进行动态内存分配。
4. 结构体的声明：

//例如描述一个学生：
 struct Stu
  {
	  char name[20];
	  int age;
	  char sex[5];
	  char id[20];
};
//特殊的声明：在声明结构的时候可以不完全的声明
//例如：匿名的结构体类型
struct
{
	int a;
	char b;
	float c;
}x;
//结构体的成员可以是标量、数组、指针，甚至是其他结构体。

//结构体成员的访问：结构体变量的成员是通过点操作符（.）访问的。点操作符接受两个操作数。
struct Stu s;//定义结构体变量
s.age=20;//对成员进行定义

//结构体访问指向变量的成员，当一个结构体变量为指针变量时，如何访问？
struct Stu *ps;
//两种方式：
(*ps).age=10;
ps->age=10;

5.结构的自引用：

//结构体的自引用一定通过指针
typedef struct Node
{
	int data;
	struct Node* next;
}Node;

6 结构的不完整声明

struct A
{
	int _a;
	struct B* pb;
};
struct B
{
	int _b;
	struct A* pa;
};
//上述为不完整的声明，不知道A与B谁先放在前面，以下为解决方案
struct B;
struct A
{
	int _a;
	struct B* pb;
};
struct B
{
	int _b;
	struct A* pa;
};

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

struct point
{
	int x;
	int y;
}P1;	//声明的同时定义了变量P1
struct point P2;  //定义结构体变量P2
struct point P3={x，y};//定义的同时可以赋值

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

struct Node n2={20,{5,6},NULL};

8.结构体的内存对齐

• 为什么存在内存对齐？
  1.平台原因：不是所有的硬件平台都能访问任意地址上的任意数据；某些硬件平台只能在某些地址取某些特定类型的数据，否则抛出硬件异常。
  2.性能原因：数据结构应该尽可能地在自然边界上对齐，原因是，访问为对齐的内存，处理器需要做两次内存访问，而对齐的内存访问只需一次的访问。
• 结构体的对齐规则：
  1.第一个成员在与结构体变量偏移量为0的地址处；
  2.其他成员要对齐到某个数字（对齐数）的整数倍地址处。
  对齐数=编译器默认的一个对齐数与该成员大小的较小值。VS中默认为8，Linux默认为4；
  3.结构体总大小为最大对齐数的整数倍；
  4.在嵌套了结构体的情况，嵌套的结构体对齐到自己最大对齐数的整数倍处，结构体的整体大小为所有最大对齐数的整数倍。
  举例：

struct S1
{
	char c1;  //1   
	//0放c1
	//int型对齐数为4，因此1-2浪费
	int i;    //4
	//3-6放整数i
	char c2;  //1
	//7放c2，8-10浪费
};
printf("%d\n",sizeof(struct S1));//取最大对齐数的整数倍为12

struct S2
{
	char c1;  //1   
	//0放c1
	char c2;  //1
	//1放c2
	//int型对齐数为4，因此2浪费
	int i;    //4
	//3-6放整数i
};
printf("%d\n",sizeof(struct S1));//取最大对齐数的整数倍为8

struct S3
{
	double d;  //8   
	//0-7放d
	char c;  //1
	//8放c
	//int型对齐数为4，因此9-11浪费
	int i;    //4
	//12-15放i
};
printf("%d\n",sizeof(struct S1));//取最大对齐数的整数倍为16

//结构体嵌套
struct S4
{
	char c1;  //1   
	//0放c1
	//1-7浪费
	struct S3 s3;  //16
	//S3最大对齐数8开始，则从8-23放s3
	double d;   //8
	//24-31放d
};
printf("%d\n",sizeof(struct S1));//取最大对齐数的整数倍为32

结构体传参

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;
}	
//补充：函数传参的时候，参数是需要压栈的，传递一个结构体对象的时候，结构体过大，参数压栈的系统开销较大，所以会导致性能的下降，因此结构体传参优选传结构体地址！

位段

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

1. 位段的成员必须是：int、unsigned int 、signed int或是char（属于整型家族）类型。
2. 位段的成员名后面有一个冒号和一个数字。
3. 例如:

struct A
{
	int a:2;
	int b:5;
	int c:10;
	int d:30;
};
//该位段类型的大小是多少？
printf("%d\n",sizeof(struct A));   //8
//如何计算的呢？
//2+5+10+30=47（bit）=6字节
//该位段对齐数为4字节，因此大小应为4的倍数，因此结果为8。

4.总结：

• 位段的空间上是按照需要以4个字节（int）或1个字节（char）的方式开辟的。
• 与结构体相比，位段可以达到同样的效果，又可以很好的节省空间，但涉及很多不确定因素，且位段是跨平台的，注重可移植性的程序避免使用。

###枚举类型
将可能的取值一一列举，可能的取值都是有值的，默认从0开始，一次递增1，也可以在定义的时候赋初值。
例如：

//定义颜色
enum Color
{
	RED,//0
	GREEN,//1
	BLUE,//2
	YELLOW//3
};
//类型重命名
typedef enum Sex
{
	GIRL,
	BOY
}Sex;
//赋初值
enum color
{
	RED,//0
	GREEN=255,//255
	BLUE//256
}

• 枚举的优点：
  1.增加代码的可读性和可维护性；
  2.和#define定义的标识符比较枚举有类型检查，更加严谨；
  3.防止了命名污染；
  4.便于调试；
  5.使用方便，一次可以定义多个常量。

###联合（共用体）
联合是一种特殊的自定义类型，这种类型定义的变量包含的一系列成员共用同一块内存空间，这样联合的大小至少是最大成员的大小（注意：当最大成员的大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍）。
例如：

//联合体的声明
union Un
{
	char c;//1
	int i;//4
};
//联合体的定义
	union Un un;
//计算连个变量的大小
	printf("%d\n",sizeof(un));//4
	printf("%d\n", &(un.i));//3014152
	printf("%d\n", &(un.c));//3014152
	//共用一块空间，地址相同
	un.i = 0x11223344;
	un.c = 0x55;
	printf("%x\n", un.i);//11223355
	//由于共用一个空间，所以i会因c发生改变。

//由联合体的特点可以用联合体判断大小端
int check_sys()
{
	union Un
	{
		char c;
		int i;//两个变量共用一个空间，起始地址相同
	}un;
	un.i=1;
	return un.c;//c可以代表i的前一个字节的地址。
}