【C语言学习笔记 --- 自定义类型】

C语言进阶之自定义类型

前言：
通过C语言进阶的字符串函数和内存函数的知识，这篇就继续学习C语言的自定义类型的相关内容。

/知识点汇总/
C语言的自定义类型
1.结构体
2.枚举
3.联合体

1、结构体

结构体：是一些值的集合，这些值称为成员变量，结构体的每个成员可以是不同类型的变量
数组：是一组相同类型的元素集合

1.1、结构体的声明

格式：

struct tag
{
	member list; //成员列表
}variable list; //结构体变量
1
2
3
4

#include 

struct Student
{
	char name[20];
	int age;
	char sex[5];
	float score;
}s1,s2,s3;//三个结构体变量 --- 全局变量

struct Book
{
	char name[20];
	char author[12];
	float price;
};
struct Book
{
	char name[20];
	char author[12];
	float price;
}b1;
int main()
{
	struct Student s4, s5, s6;//三个结构体变量 ---局部变量
	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

结构体的一种特殊声明：结构体匿名

#include 
struct Student
{
	char name[20];
	int age;
	char sex[5];
	float score;
}s1,s2,s3;//三个结构体变量 --- 全局变量

//一种特殊声明，匿名声明，只会执行一次。一次性
struct 
{
	char name[20];
	char author[12];
	float price;
}b1;
struct 
{
	char name[20];
	char author[12];
	float price;
}*p;
int main()
{
	struct Student s4, s5, s6;//三个结构体变量 ---局部变量
	
	//不建议使用匿名写法
	p = &b1;
	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

1.2、结构体的自引用

结构体的自引用：就是在结构体内部,包含指向自身类型结构体的指针
错误的写法示例：

struct Node
{
	int data;//数据
	struct Node n;//下一个节点
};
1
2
3
4
5

正确的引用方法：

//正确自引用写法1：
struct Node
{
	int data;//数据
	struct Node* n;//下一个节点
};

//正确写法2：
typedef struct Node
{
	int data;//数据
	struct Node* n;//下一个节点
}Node;
1
2
3
4
5
6
7
8
9
10
11
12
13

小结：
结构体里包含一个同类型的结构体不可行，但可以包含一个同类型的指针结构体可行

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

#include 
struct Point
{
	int x;
	int y;
}p1 = { 1,2 };//初始化方式一
struct Point p3 = { 4,5 };//初始化方式二
struct Stu
{
	char name[15];
	int age;
};
struct Node
{
	int data;
	struct Point p;
	struct NOde* next;
};
int main()
{
	int a = 3;
	int b = 4;
	struct Point p2 = { a,b };//初始化方式三
	
	struct Stu s = { "lisi",20 };//顺序初始化
	struct Stu s1 = { .age = 18,.name = "zhangsan" };//指定顺序或指定成员初始化
	printf("%s %d\n", s.name, s.age);
	printf("%s %d\n", s1.name, s1.age);

	struct Node n = { 100,{3,4},NULL };
	printf("%d x=%d y=%d\n", n.data, n.p.x, n.p.y);
	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
32
33

1.4、结构体内存对齐

#include 
struct S1
{
	char c1;
	int i;
	char c2;
};
struct S2
{
	char c1;
	char c2;
	int i;
};
int main()
{
	printf("%d\n", sizeof(struct S1));//12
	printf("%d\n", sizeof(struct S2));//8
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

offsetof – 宏 — 可直接使用
原型：size_t offsetof( structName, memberName );
头文件：
功能：计算结构体成员相较于起始位置的偏移量

#include 
#include 
struct S1
{
	char c1;
	int i;
	char c2;
};
struct S2
{
	char c1;
	char c2;
	int i;
};
int main()
{
	//offsetof -- 计算起始位置的偏移量
	printf("%d\n", offsetof(struct S1, c1));//0
	printf("%d\n", offsetof(struct S1, c2));//8
	printf("%d\n", offsetof(struct S1, i));//4

	printf("%d\n", offsetof(struct S2, c1));//0
	printf("%d\n", offsetof(struct S2, c2));//1
	printf("%d\n", offsetof(struct S2, i));//4
	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

小结：
观看可知，结构体定义的所开辟的内容完全相同，但是所在的字节大小却不同
原理：结构体内存对齐

1.5、探究结构体内存对齐

1.怎么对齐？
2.为什么要对齐？

标准规定：
结构体对齐的规则：

1.结构体的成员在与结构体变量偏移量为0的地址处开始存储
2.结构体其它成员变量要对齐到某个数字(对齐数)的整数倍的地址处存储
对齐数 = 编译器默认的一个对齐数与该成员大小的较小值

其中，VS编译器默认为8 Linux中默认为没有对齐数，对齐数就是成员自身的大小（gcc编译器下）

3.结构体总大小为最大对齐数(每个成员变量都有一个对齐数)的整数倍
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍

1.怎么对齐？
根据规则可知，对齐偏移量与变量的类型相关，先根据变量类型的得到偏移量再和当前VS编译器的默认对齐数8作比较，选择最小的为该变量的对齐数，也就是存储空间所开辟的空间大小。
最后，结构体的总大小，必须是所有结构体成员的最大的对齐数的整数倍，如果不是整数倍，则继续开辟空间直到成为整数倍。

#include 
struct S1
{
	char c1;
	char c2;
	int i;
};
struct S2
{
	char c1;
	int i;
	char c2;
};
struct S3
{
	double d;
	char c;
	int i;
};

struct S4
{
	char c1;
	struct S3 s3;
	double d;
};
int main()
{
	printf("%d\n", sizeof(struct S1));//8
	printf("%d\n", sizeof(struct S2));//12
	printf("%d\n", sizeof(struct S3));//16
	printf("%d\n", sizeof(struct S4));//32
	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
32
33
34

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

3.总体来说：结构体的内存对齐是针对于拿空间来换取时间的做法。
那么如果在设计结构体时，既要满足对齐，又要节省空间，如何做到呢？
(1)、让占用空间小的成员变量尽量集中在一起。
比如：

struct S1
{
	char c1;
	char c2;
	int i;
};
struct S2
{
	char c1;
	int i;
	char c2;
};
1
2
3
4
5
6
7
8
9
10
11
12

(2)、引用#pragma，预处理指令，修改默认对齐数

#include 
struct S1
{
	char c1;
	char c2;
	int i;
};
#pragma pack(1)//设置默认对齐数为1
struct S2
{
	char c1;
	int i;
	char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为编译器默认值
int main()
{
	printf("%d\n", sizeof(struct S1));//8
	printf("%d\n", sizeof(struct S2));//6
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

小结：
所以遇见结构体对齐方式不合适时，也可以通过#pragma预处理指令修改默认对齐数（通常为偶数）

1.6、结构体传参

结构体传参分类：结构体传值调用和传址调用

#include 
struct S
{
	int data[1000];
	int num;
};
void print(struct S t)
{
	printf("%d %d %d %d\n", t.data[0], t.data[1], t.data[2], t.num);
}
void print2(struct S* ps)
{
	printf("%d %d %d %d\n", ps->data[0], ps->data[1], ps->data[2], ps->num);
}
int main()
{
	struct S s = { {1,2,3},100 };
	print(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

小结：
1.函数传参时，参数是需要压栈的，会有时间和空间上的系统开销
2.如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销比较大，所以会导致性能的下降

2、枚举

顾名思义就是一一列举数据
把可能的值一一列举出来

比如生活中一些可以一一列举出来的数据：
1.一周有七天，可以从周一到周日一一列举
2.性别有男有女，可以一一列举
3.月份有12个月，可以一一列举

2.1、枚举类型的定义、使用和初始化

#include 
//宏定义常量
#define MALE  1
#define FEMALE  2
#define SECRET  3
enum Sex
{
	//枚举的可能取值
	MALE,//注意，枚举常量以逗号隔开
	FEMALE,
	SECRET
};
enum Color
{
	//枚举的可能取值
	RED,
	GREEN,
	BLUE
};
enum Week
{
	Mon = 1,//赋初始值
	Tues = 2,
	wed = 3,
	Thur = 4,
	Fri = 5,
	sat = 6,
	Sun = 7
};
int main()
{
	//MALE = 5; ---- Error,因为枚举常量属于常量，不可以给常量赋值，常量是不可更改的
	printf("%d\n", MALE);//0
	printf("%d\n", FEMALE);//1
	printf("%d\n", SECRET);//2
	//枚举成员常量不赋予初值时，默认从0开始递增的

	//枚举类型的使用：
	enum Sex sex = SECRET;//相当于将一个常量赋值给变量sex
	//也类似于宏定义常量的使用
	printf("%d\n", sizeof(sex));//4,打印查看枚举常量的大小，整型4个字节
	
	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
32
33
34
35
36
37
38
39
40
41
42
43
44

小结：
我们可以使用#define定义常量，那么为什么使用枚举？
枚举的优点：
1.增加代码的可读性和维护性
2.和#define定义的标识符比较，枚举有类型检查，更加严谨
3.便于调试
4.使用方便，一次可定义多个常量

枚举类型的使用差异

#include 
enum Sex
{
	MALE,
	FEMALE,
	SECRET
};
int main()
{
	//枚举类型的使用：
	enum Sex sex = SECRET;
	//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异
	sex = 5;//会有类型的差异，比如在cpp条件下就会报错（enum类型 与 int类型不匹配，类型差异）
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3、联合(共用体)

定义：联合也是一种特殊的自定义类型；这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间(所以联合也叫共同体)。
联合体的关键字：union
联合体成员与结构体成员类型类似可是多种类型
联合体的特点：
联合体的成员是共用一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小(因为联合至少得有能力保存最大的那个成员)

#include 
union Un
{
	char c;//联合体成员跟结构体成员一样用分号隔开
	int i;
};
int main()
{
	union Un un;
	printf("%d\n", sizeof(un));//4

	//共用一块地址
	printf("%p\n", &un);//0073F6EC
	printf("%p\n", &(un.c));//0073F6EC
	printf("%p\n", &(un.i));//0073F6EC
	//所以当联合体成员被修改，可能导致其他的成员也跟着相应变化
	//所以在使用联合体成员时，不建议同时操作数据。
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3.1、回顾大端小端的判断 — 联合体的应用

小端存储：低地址数据存放在低地址处，高地址数据存放在高地址处
大端存储：低地址数据存放在高地址处，高地址数据存放在低地址处
写法一：

#include 
int check_sys()
{
	int a = 1;
	//if (*(char*)&a == 1)//&a类型是int* 
	//	return 1;
	//else
	//	return 0;
	return *(char*)&a;
}
int main()
{
	int ret = check_sys();
	if (ret == 1)
		printf("小端\n");
	else
		printf("大端\n");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

写法二： 联合体应用

#include 
int check_sys()
{
	union Un//当Un省略就是匿名联合体，此时可以使用，因为这里联合体只需要执行一次与匿名结构体、匿名联合体的性质吻合，只执行一次
	{
		char c;
		int i;
	}u;
	u.i = 1;
	//因为i和c是联合体变量，所以共用一块内存空间
	//并且当给i赋值给1，以十六进制表示为：0x00 00 00 01
	//所以我们返回c的值，如果c等于0，则高地址数据存放在低地址处，
	//否则c为1，低地址处数据存放在低地址处
	return u.c;
}
int main()
{
	int ret = check_sys();
	if (ret == 1)
		printf("小端\n");
	else
		printf("大端\n");
	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

3.2、联合体的大小计算

1.联合体的大小至少是最大成员的大小
2.当最大成员大小不是最大对齐数的整数倍时，就要对齐到最大对齐数的整数倍

#include 
union Un
{
	char c[5];//5
	int i;//4
};
int main()
{
	printf("%zd\n", sizeof(union Un));//8
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

#include 
union Un
{
	short c[7];//14
	int i;//4
};
int main()
{
	printf("%zd\n", sizeof(union Un));//16,共用一块地址且是4的倍数，对齐后16
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

小结：
联合体的使用场景，常见于，某些成员不会在同一时间使用。
使用联合体也是可以节省空间的。

4、结语

熟悉以上内容以后对C语言的使用更利于程序的可读性和效率，此篇笔记有误的地方请多多指教。
半亩方糖一鉴开，天光云影共徘徊。
问渠哪得清如许?为有源头活水来。–朱熹（观书有感）