自定义类型

---

1、结构体

1.1结构体的声明

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

结构体的声明

struct tag
{
	member-list;
}variable-list;

例如：创建一个描述学生的结构体

struct Stu
{
	char name[20];//姓名
	int age;//年龄
	char sex[5];//性别
	char id[20];//学号
};//记住分号不能丢！

特殊的声明：

除了上述的声明方式外，我们还可以用匿名对象进行声明；

struct
{
	char a;
	int b;
	float c;
}x;

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

根据上述代码，你觉得下述表达式是否正确？

p = &x;

可能很多人会觉得两个结构体类型完全一摸一样，那肯定是对的；但其实是不正确的！
编译器会把上面两个声明当作是两种完全不同的类型，所以是非法的！

1.2 结构体的自引用

在结构体中，是否可以包含一个类型为结构体本身呢？

struct Node
{
	int val;
	struct Node next;
};

如果可以，那sizeof(struct Node)又是多少呢？

可以看到，编译器不允许在结构体内部包含结构体本身！
为什么呢？
如果结构体包含结构体本身，那么这样就有点类似于死递归永远都求不出大小（struct Node中包含一个struct Node,但struct Node里又包含了一个val和struct Node)

正确的结构体自引用

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

struct Node中包含一个val和一个结构体指针，而结构体指针又指向了一个类型为struct Node的数据。

下面的自引用是否也合理呢？

typedef struct Node
{
	int val;
	Node* next;
}Node;//将struct Node 重命名为Node

可以看到，这样是不合理的！
原因是：
重命名是在结构体完全声明完毕后才能进行的；但上面的代码的意思是在结构体还没声明完全时就已经对结构体进行重命名，这是不允许的！

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

有了结构体类型后，如何定义结构体就十分简单了

struct Point
{
	int x;
	int y;
}p1; //在声明类型的同时创建变量p1

struct Point p2;//定义变量p2

struct Point p3 = {1,2};//定义变量的同时初始化

struct Stu //类型声明
{
	char name[20];
	int age;
};
struct Stu s1 = {"zhangsan",14};

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

struct Node n2 = {2,{2,3},NULL};

1.4 结构体内存对齐

结构体内存对齐经常作为笔试题出现，我们先来看看下述代码

struct S1
{
	char c1;
	int i;
	char c2;
};

struct S2
{
	char c1;
	char c2;
	int i;
};

int main()
{
	printf("%d\n", sizeof(struct S1));
	printf("%d\n", sizeof(struct S2));
	return 0;
}

上述代码分别打印什么？

或许你会这么想：c1占1个字节，i占4个字节，c2占1个字节，总计不就是6个字节吗？分别打印的不就都是6吗？不很简单吗？
但答案肯定会出乎你的意料！

结构体大小完全与我们想象中的不一样！这是为什么呢？要如何计算结构体大小呢？

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

什么是偏移量？

在创建结构体变量时，第一个成员的首地址就相当于偏移量为0的地址，按一个字节+1的规律以此类推；

根据上述规则，我们来分析下之前的两道计算结构体大小的题目

struct S1
{
	char c1;
	int i;
	char c2;
};

struct S2
{
	char c1;
	char c2;
	int i;
};

int main()
{
	printf("%d\n", sizeof(struct S1));
	printf("%d\n", sizeof(struct S2));
	return 0;
}

对struct S1进行分析：

1.假设创建一个结构体变量，类型为struct S1；
2.根据规则1得知：c1存放在偏移量为0的地址处

3.根据规则2：其他成员变量要对齐到对齐数的整数倍的地址处；我们必须先求出i的对齐数：成员变量i的类型大小为4，而默认对齐数为8，取较小值4为对齐数；由于偏移量为4的地址处能被4整除，所以i应该存放在偏移量为4的地址处。

4.同样的根据规则2，我们得先求出c2的对齐数：成员变量c2的类型大小为1，而默认对齐数为8，取较小值1为对齐数；由于下一个偏移量为8，8是偏移量1的倍数，所以c2存放在偏移量为8的地址处。

5.你以为这样就结束了吗？还没有！
根据规则3：结构体的总大小为最大对齐数的整数倍；
由于我们已经知道了各个成员的对齐数，分别为 ：4，1；其中最大对齐数为4；此时结构体的总大小为9个字节，9并不是4的倍数，所以需要继续浪费3个字节的空间，来到达偏移量为12的地址处。

对struct S2进行分析：

1.假设先创建一个类型为struct S2的变量
2.根据规则1知：c1存放在偏移量为0的地址处
3.根据规则2知：c2的对齐数为1，对应的偏移量为1，所以c1存放在偏移量为1的地址处
4.根据规则2知：i的对齐数为4，对应最近的偏移量应该为4，所以浪费两个字节的空间，将i存放在偏移量为4的地址处
5.根据规则3知：结构体总大小目前为8，最大对齐数为4，8是4的倍数，所以不需要继续浪费空间。

那么如何得知我们计算的偏移量是对的呢？

C语言为我们提供了一个宏函数offsetof,用来计算结构体成员的偏移量

offset(type,member)
//第一个参数为结构体类型
//第二个参数为结构体成员变量

对成员类型相同但大小却不同的结构体的讨论

在创建结构体时，我们既要满足对齐，又要节省空间，这时我们就要尽可能的把占用空间小的类型集中在一起；

计算结构体内嵌套结构体后的总大小

struct S3
{
	char c;
	struct S2;
	double d;
};

int main()
{
	printf("%zu\n",sizeof(struct S3));
	return 0;
}

思路分析：

1. 假设创建结构体变量
2. 根据规则1：我们将c存放在偏移量为0的地址处；

3.由于已经得知S2的总大小为8个字节，那么根据规则4：嵌套的结构体对齐到自己的最大对齐数的整数倍处，S2的最大对齐数是4，所以需要浪费三个字节的空间到达偏移量为4的地址处存放struct S2结构体类型；

4. 根据规则2得知：d的对齐数为8，由于12不是8的倍数，所以需要浪费4个字节的空间来到达偏移量为16的地址处来存放d；

5. 目前结构体的总大小为24个字节，最大对齐数为8，24是8的倍数，满足规则3，完成大小判断！

为什么需要结构体内存对齐

1.平台原因（移植原因）：
不是所有的硬件平台都能访问任意地址上的任意数据的：
某些硬件平台只能在某些地址处取得某些特定类型的数据，否则抛出硬件异常。
2.性能原因：
数据结构（尤其是栈）应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐得内存，处理器需要作两次内存访问，而对齐了的内存访问只需要一次访问；
例如：

struct S
{
	char a;
	int b;
	int c;
};

假设目前处在32位机器下，32位机器每次都是按照32个bit位读取数据；假设现在需要取出b中的数据；
没有内存对齐取数据： 由于是4个字节4个字节读取数据，所以需要先从a的地址处开始读4个字节的数据，但还少了b末尾的1个字节数据，需要再读一次才能取出完整的b中的数据；


有内存对齐读取数据： 由于存在内存对齐，b在进行读取的时候只进行了1次

总体来说，结构体内存对齐是一种以空间换时间的做法

修改默认偏移量

使用#pragma预处理指令，可以改变默认偏移量

#pragma park(4)//设置默认偏移量为4
struct S1
{
	char c1;
	int i;
	char c2;
};
#pragma park()//恢复默认偏移量为8


#pragma park(1)//设置默认偏移量为1
struct S2
{
	char c1;
	char c2;
	int i;
};
#pragma park()//恢复默认偏移量

1.5 结构体传参

struct S
{
	int data[1000];
	int num;
};

void print1(struct S s)
{
	printf("%d\n",s.num);
}

void print2(struct S* ps)
{
	printf("%d\n",ps->num);
}
int main()
{
	struct S s = {{1,2,3,4},1000};
	print1(s);//传结构体
	print2(&s);//传结构体指针
}

上面print1和print2哪种更好呢？

答案是:首选print2函数
原因是：函数传参的时候，参数是需要压栈的，会有时间和空间上的系统开销。
如果传递一个结构体对象时，结构体过大，参数压栈的系统开销比较大，所以会导致性能的下降。
结论：
结构体传参时，要传结构体指针

1.6 位段

位段只能由结构体来实现
位段的声明和结构体成员是类似的，只有两点不同：
1.位段的成员必须是int,unsigned int 或 signed int。
2.位段的成员名后有一个冒号和一个数字。
例如：

struct A
{
	int _a:2;
	int _b:5;
	int _c:10;
	int _d:30;
};

A就是一个位段类型，那么位段A的大小是多少呢？

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

我们先继续往下看看！

1.7 位段的内存分配

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

分析下面的位段是如何开辟空间的？

位段中的位指的是bit位，冒号所跟的就是该变量所需要的bit位空间；

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;
}

图解分析：
1. 由于变量是char类型的，所以是位段的空间是按照1个字节1个字节来进行开辟的；
2. a所需要的空间为3个bit位，由于占用3个bit位空间，1个字节中仍还有5个bit位可以使用
3. b需要4个bit位，5个bit用去4个，仍剩下1个
4. c需要5个bir位，1个不够用，则需要另外再开一个字节的空间–>新的空间被用去5个还剩下3个
5. d需要4个bit位，剩下的3个不够用，又需要另外再开一个字节的空间。所以最后总共开了3个字节的空间

1.8 位段的跨平台问题

1.int位段被当成有符号数还是无符号数是不确定的。（在其他情况下默认int为有符号数，位段需要亲自指定）；
2.位段中最大位的数目不能确定。（16机器最大是16，32位机器最大为32，写成27，在16位机器下会出问题）；
3.位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义；
4.当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。
总结：
跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。

2.枚举

枚举顾名思义就是一 一 列举。
把可能的取值一 一列举。
比如我们现实生活中：
一周的星期一到星期日是有限的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，在定义的时候也可以赋初值。并且可能取值只允许是整数或者是另外一个枚举常量！

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

enum Sex
{
	MALE,//0
	FEMALE = GREEN,//2
	SECRET//3
};

2.1枚举的优点

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

2.2枚举的使用

只有拿枚举常量给枚举变量赋值，才不会出现类型差异。拿整型赋值的操作是否能成功取决于编译器。

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

enum Color clr = GREEN;//OK
clr = 5;//在VS下的.c文件中是可以跑通的，但在.cpp的文件中是跑不通的，c++语法更加严格。

3.联合（共用体）

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

//联合类型的声明
union Un
{
	char c;
	int i;
};

//联合变量的定义
union Un un;

上述的联合类型占几个字节呢？

printf("%d\n",sizeof(un));

会是5个字节（int ->4 + char -> 1）吗？

3.1联合的特点

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

先来看看下述代码

union Un
{
	int i;
	char c;
};
union Un un;

//下面输出的结果是一样的吗？
printf("%d\n",&(un.i));
printf("%d\n",&(un.c));

//下面输出的结果又是什么？
un.i = 0x11223344;
un.c = 0x55;
printf("%x\n",un.i);

代码分析：
1.联合是共用一块内存空间的，由于成员中最大的类型为int，所以联合会开辟4个字节空间。
2.那么c便会用到这第一个字节，i便会用到这4个字节。
3.由于是小端存储，那么修改c就是修改第一个字节，对应的就是修改44；

3.2联合大小的计算

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

union Un1
{
	char c[5];
	int i;
};

union Un2
{
	short c[7];
	int i;
};

int main()
{
	printf("%d\n",sizeof(union Un1));
	printf("%d\n",sizeof(union Un2));
	return 0;
}

1.union Un1的分析：
1.char c[5]占5个字节，int i 占4个字节，联合的大小至少是最大成员的大小，所以此时联合的大小应该为5；
2.char c[5]的对齐数为1，int i的对齐数为4，那么最大对齐数应为4；联合的大小应该满足对齐规则，所以联合会浪费3个字节，将总大小扩到8；

2.union Un2的分析：
1.short c[7]占14个字节，int i 占4个字节，联合的大小至少是最大成员的大小，所以此时联合的大小应为14；
2.short c[7]的对齐数为2，int i的对齐数为4，那么最大对齐数为4；联合大小应满足对齐规则，所以联合浪费2个空间，将大小扩展到4的倍数->16;

3.3面试题

在数据存储那章，我们实现了用一个函数来验证当前机器是大端还是小端。学完联合后，我们也可以用联合的方式来完成这一项任务。

int get_Bytes_of_storage()
{
	int a = 1;
	//01 00 00 00
	char* pc =(char*)&a;
	//01
	return *pc;
}

int main()
{
	int ret = get_Bytes_of_storage();
	if (ret == 1)
		printf("小端\n");
	else
		printf("大端\n");

	return 0;
}

联合的方式

int get_Bytes_of_storage()
{
	union //构建匿名对象
	{
		char c;
		int i;
	}u;

	u.i = 1;
	return u.c;
}

int main()
{
	int ret = get_Bytes_of_storage();
	if (ret == 1)
		printf("小端\n");
	else
		printf("大端\n");

	return 0;
}