自定义类型：结构体，枚举，联合

前言：

那么好了好了，宝子们，从今天开始开始总结暑假博客，今天的主角：结构体，枚举，联合，来吧开始整活！⛳️

结构体

1.结构体类型的声明

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

struct Stu
{
	char name[20];
	char sex[5];
	int age;
	int id[20];
}x,y;
1
2
3
4
5
6
7

匿名结构体：

struct
{
 int a;
 char b;
 float c;
}x;
1
2
3
4
5
6

2.结构的自引用

//代码1
struct Node
{
	int data;
	struct Node next;
};
//可行否？
//如果可以，那sizeof(struct Node)是多少?

//正确自应用：
struct Node
{
 int data;
 struct Node* next;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

正确自引用：

//代码3
typedef struct
{
	int data;
	Node* next;
}Node;
//这样写代码，可行否？//no!no!no!nononono

//解决方案：
typedef struct Node
{
	int data;
	struct Node* next;
}Node;
struct Point
{
	int x;
	int y;
}p1; //声明类型的同时定义变
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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

有了结构体类型，那如何定义变量，其实很简单。
有两种定义结构体变量的方式：

1. 在结构体末尾定义：

struct Point
{
	int x;
	int y;
}p1; //声明类型的同时定义变
1
2
3
4
5

3. 单独定义：

struct Point p1;
1

综合：

//初始化：定义变量的同时赋初值。
struct Point p3 = { x,y };
//类型声明
struct Stu 
{
	char name[15];//名字
	int age; 
};
struct Stu s = { "zhangsan", 20 };//初始化
struct Node
{
	int data;
	struct Point p;
	struct Node* next;
}n1 = { 10, {4,5}, NULL }; //结构体嵌套初始化
struct Node n2 = { 20, {5, 6}, NULL };//结构体嵌套初始化
//练习1
struct S1
{
	char c1;
	int i;
	char c2;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

4.结构体内存对齐

结构体对齐的准则：
通俗易懂版：
官方版:

这也是一个特别热门的考点： 结构体内存对齐
管中窥豹（例一：）

//练习一：
struct S1
{
	char c1;//
	int i;
	char c2;
};
1
2
3
4
5
6
7
8

透析：

通过例题来理解结构体内存对齐规则：

//练习一：
struct S1
{
	char c1;//1 8 1
	int i;//4 8 4
	char c2;//1 8 1
};

//练习二：
struct S2
{
	char c1;//1 8 1
	char c2;//1 8 1
	int i;//4 8 4
};

//练习3
struct S3
{
	double d;//8 8 8
	char c;//1 8 1
	int i;//4 8 4
};
int main()
{
	printf("%d\n", sizeof(struct S1));//12
	printf("%d\n", sizeof(struct S2));//8
	printf("%d\n", sizeof(struct S3));//16

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

5.结构体传参

直接上代码：

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

6.结构体实现位段（位段的填充&可移植性）

结构体讲完就得讲讲结构体实现 位段 的能力。
位段的最小单位是：比特位（bit）

什么是位段
位段的声明和结构是类似的，有两个不同：
1.位段的成员必须是 int、unsigned int 或signed int 。
2.位段的成员名后边有一个冒号和一个数字。
例一：

struct A
{
	int _a : 2;//一次性开辟一个整型=4*8=32bit
	int _b : 5;
	int _c : 10;//a,b,c这三个公用第一次开辟的4个字节（int）=32bit

	int _d : 30;//从新开辟
};

int main()
{
	printf("%d\n", sizeof(struct A));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

也就是每次开辟空间的时候，都开辟一个数据类型的大小
（int=4个字节=48=32bit）
（char=1个字节=18=8bit）
位段计算规则：

//一个例子
struct S
{
	char a : 3;
	char b : 4;//a和b一个字节

	char c : 5;
	char d : 4;
};
int main()
{
	printf("%d\n", sizeof(struct S));
	return 0;
}
//空间是如何开辟的？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

枚举

1.枚举类型的定义

enum Day//星期
{
	Mon,
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sun
};
enum Sex//性别
{
	MALE,
	FEMALE,
	SECRET
};
enum Color//颜色
{
	RED,
	GREEN,
	BLUE
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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

2.枚举的优点

我们可以使用 #define 定义常量，为什么非要使用枚举？ 枚举的优点：

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

3.枚举的使用

enum Color//颜色
{
 RED = 1,
 GREEN = 2,
 BLUE = 4
};
enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
clr = 5;
1
2
3
4
5
6
7
8

联合

1.联合类型的定义

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

//联合类型的声明
union Un
{
 char c;
 int i;
};
//联合变量的定义
union Un un;
//计算连个变量的大小
printf("%d\n", sizeof(un));
1
2
3
4
5
6
7
8
9
10

2.联合的特点

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

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
2
3
4
5
6
7
8
9
10
11
12
13
14

3.联合大小的计算

联合体大小计算的准则：

union Un1
{
 char c[5];
 int i;
};
union Un2
{
 short c[7];
 int i;
};
//下面输出的结果是什么？
printf("%d\n", sizeof(union Un1));
printf("%d\n", sizeof(union Un2));
1
2
3
4
5
6
7
8
9
10
11
12
13

Un1:它里面最大成员的大小是1×5=5，但是还要满足联合体的大小是最大对齐数的整数倍，最大对齐数是4。也就是最终的结果是4的倍数，所以说不仅要大于5，而且要是4的倍数，所以说是8。
Un2:它里面最大成员的大小是2×7=14，但是还要满足联合体的大小是最大对齐数的整数倍，最大对齐数是4，也就是最终的结果是4的倍数，而且还要大于14，所以说是16。

---

好了，今天的分享就到这里了

如果对你有帮助，记得点赞👍+关注哦！
我的主页还有其他文章，欢迎学习指点。关注我，让我们一起学习，一起成长吧！
好了，今天的分享就到这里了