自定义类型——结构体、联合体、枚举

一、结构体

        1.结构体类型的声明        

         例如描述⼀个学⽣：

#include <stdio.h>
struct student
{
	char name[20];
	int age;
	char sex[10];
	char id[20];
};//；不能少
int main()
{
	struct student s1 = { "zhangsan",18,"male","12345678910"};
	printf("%s\n", s1.name);
	printf("%d\n", s1.age);
	printf("%s\n", s1.sex);
	printf("%s\n", s1.id);
	struct student s2 = { .age = 20,.id = "123456789",.sex = "female",.name = "lisi"};
	printf("%s\n", s2.name);
	printf("%d\n", s2.age);
	printf("%s\n", s2.sex);
	printf("%s\n", s2.id);
	return 0;
}

        像s1，是按照结构体成员的顺序初始化，s2便是按照指定的顺序初始化，大家在写代码时可参考以上两种写法。

        2. 结构的特殊声明

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

        如以下写法：

struct 
{
	char name[20];
	int age;
	char sex[10];
	char id[20];
}s;

        注意：这种结构体类型称为匿名结构体类型，只能够使用一次。

        3.结构的⾃引⽤

        选择我们已经初步的了解了结构体，那我们能不能像下面的代码一样，对结构体进行自引用呢？

struct s
{
	char name[20];
	int age;
	char sex[10];
	char id[20];
	struct Node next;
};

        相信你们此时已经有答案了，答案如图所示：

         仔细分析，其实是不⾏的，因为⼀个结构体中再包含⼀个同类型的结构体变量，这样结构体变量的⼤ ⼩就会⽆穷的⼤，是不合理的。

        我们先前已学习了指针，那我们可不可以用指针的方式来解决这个问题呢？答案是显而易见的。

struct s
{
	char name[20];
	int age;
	char sex[10];
	char id[20];
	struct Node* next;
};

        我们得出如下结论：要实现结构体自引用时，要传入被引用结构体的地址。

二、对⻬规则

        1.什么是对齐规则

        1. 结构体的第⼀个成员对⻬到和结构体变量起始位置偏移量为0的地址处

        2. 其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处。 对⻬数 = 编译器默认的⼀个对⻬数 与 该成员变量⼤⼩的较⼩值。

        - VS 中默认的值为 8

        - Linux中 gcc 没有默认对⻬数，对⻬数就是成员⾃⾝的⼤⼩

         3. 结构体总⼤⼩为最⼤对⻬数（结构体中每个成员变量都有⼀个对⻬数，所有对⻬数中最⼤的）的 整数倍。

         4. 如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处，结构 体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍。 

#include <stdio.h>
struct s1
{
	char a1;
	int b1;
	char c1;
};
struct s2
{
	char a2;
	char c2;
	int b2;
};
struct s3
{
	double a3;
	char b3;
	int c3;
};
struct s4
{
	char c4;
	struct s3 i;
	int b4;
};
test1()
{
	printf("%d\n", sizeof(struct s1));
}
test2()
{
	printf("%d\n", sizeof(struct s2));
}
test3()
{
	printf("%d\n", sizeof(struct s3));
}
test4()
{
	printf("%d\n", sizeof(struct s4));
}
int main()
{
	test1();
	test2();
	test3();
	test4();
	return 0;
}

        大家可以先试着做一做，下面是答案： 

         大家若有什么不懂之处，可以在评论区交流。‘

        2.为什么存在内存对⻬?

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

         2. 性能原因： 数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于，为了访问未对⻬的内存，处理器需要 作两次内存访问；⽽对⻬的内存访问仅需要⼀次访问。假设⼀个处理器总是从内存中取8个字节，则地 址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对⻬成8的倍数，那么就可以 ⽤⼀个内存操作来读或者写值了。否则，我们可能需要执⾏两次内存访问，因为对象可能被分放在两 个8字节内存块中。

         总体来说：结构体的内存对⻬是拿空间来换取时间的做法。

        那我们如何，在满足对齐规则的前提下，节约空间呢？

        从上面test1和test2中可以看出要想满足的最优解是：把相同大小的集中到一起。

三、结构体实现位段 

        1.什么是位段？

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

         1. 位段的成员必须是 int、unsigned int 或signed int ，在C99中位段成员的类型也可以 选择其他类型。

         2. 位段的成员名后边有⼀个冒号和⼀个数字。

struct S
{
	int a : 5;
	char b : 3;
};

         2.位段的内存分配

         1. 位段的成员可以是 int unsigned int signed int 或者是 char 等类型

        2. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的⽅式来开辟的。

         3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使⽤位段。

#include <stdio.h>
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;
}

 

        存入的数字会转换成二进制，根据其占据比特位的大小进行存储。

        3.位段的跨平台问题 

        1. int 位段被当成有符号数还是⽆符号数是不确定的。

         2. 位段中最⼤位的数⽬不能确定。（16位机器最⼤16，32位机器最⼤32，写成27，在16位机器会 出问题。

         3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。

         4. 当⼀个结构包含两个位段，第⼆个位段成员⽐较⼤，⽆法容纳于第⼀个位段剩余的位时，是舍弃 剩余的位还是利⽤，这是不确定的。

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

        4.位段的应⽤

        下图是⽹络协议中，IP数据报的格式，我们可以看到其中很多的属性只需要⼏个bit位就能描述，这⾥ 使⽤位段，能够实现想要的效果，也节省了空间，这样⽹络传输的数据报⼤⼩也会较⼩⼀些，对⽹络 的畅通是有帮助的。

四、联合体 

        1.联合体类型的声明

         像结构体⼀样，联合体也是由⼀个或者多个成员构成，这些成员可以不同的类型。 但是编译器只为最⼤的成员分配⾜够的内存空间。联合体的特点是所有成员共⽤同⼀块内存空间。所以联合体也叫：共⽤体。 给联合体其中⼀个成员赋值，其他成员的值也跟着变化。

#include <stdio.h>
union Un
{
	char c;
	int i;
};
int main()
{
	union Un un = { 0 };
	printf("%d\n", sizeof(un));
	return 0;
}

        2.联合体的特点

        联合的成员是共⽤同⼀块内存空间的，这样⼀个联合变量的⼤⼩，⾄少是最⼤成员的⼤⼩（因为联合 ⾄少得有能⼒保存最⼤的那个成员）。

        3.联合的⼀个练习

        写⼀个程序，判断当前机器是⼤端？还是⼩端？

#include <stdio.h>
union Un
{
	char i;
	int a;
};
int main()
{
	union Un u = { 0 };
	u.a = 1;
	if (u.i == 1)
	{
		printf("小端存储");
	}
	else
	{
		printf("大端存储");
	}
	return 0;
}

五、枚举

        1.枚举类型的声明

        枚举顾名思义就是⼀⼀列举。 把可能的取值⼀⼀列举。

         ⽐如我们现实⽣活中：

         ⼀周的星期⼀到星期⽇是有限的7天，可以⼀⼀列举

         性别有：男、⼥、保密，也可以⼀⼀列举

         ⽉份有12个⽉

        也可以⼀⼀列举 三原⾊，也是可以意义列举

         这些数据的表⽰就可以使⽤枚举了。

enum Day
{
	Mon,
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sun
};
enum Sex
{
	MALE,
	FEMALE,
	SECRET
};
enum Color
{
	RED,
	GREEN,
	BLUE
};

        以上定义的 enum Day ， enum Sex ， enum Color 都是枚举类型。 {}中的内容是枚举类型的可能取值，也叫 枚举常量 。 这些可能取值都是有值的，默认从0开始，依次递增1，当然在声明枚举类型的时候也可以赋初值。

        2.枚举类型的优点

        枚举的优点：

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

        2. 和#define定义的标识符⽐较枚举有类型检查，更加严谨。

         3. 便于调试，预处理阶段会删除 #define 定义的符号

         4. 使⽤⽅便，⼀次可以定义多个常量

         5. 枚举常量是遵循作⽤域规则的，枚举声明在函数内，只能在函数内使⽤