结构体-枚举-联合体 ---详解_结构体内部包含了枚举

结构体

结构体的意义：结构体，通俗讲就像是打包封装，把一些有共同特征（比如同属于某一类事物的属性，往往是某种业务相关属性的聚合）的变量封装在内部，通过一定方法访问修改内部变量。具体一点说，结构体是让一些很散的数据变得很整，不管是网络传输，还是函数传参，还是为了便于你肉眼管理。
一个函数，你想传入一个参数void func()，就需要改一下函数定义，加一个数据类型和数据名void func(int i)；又想加一个参数，又改一遍void func(int i,double b)；如此往复。但是用一个结构体（或者类对象）传入，这个函数定义就可以不改动了，只改结构体就好了，比如一个游戏，你的人物属性有成百上千，你只需要修改你的类与结构体成员就好了。

1.结构体的声明：

声明一个结构体类型的一般形式为：
struct 结构体名
{成员列表}；
代码解释：

struct Stu//struct 结构体名
{
//成员列表
   char name[20];//名字
   int age;//年龄
   char sex[5];//性别
   char id[20];//学号
}; //分号不能丢

1
2
3
4
5
6
7
8
9

结构体初始化：

1.要定义结构变量，则一般形式是：

struct 结构体名 结构体变量名;

struct stu test = {"zhangsan",88,nan,{1,2,3,4}};
1

2.定义后逐个赋值:

struct stu test；

test.name= "zhangsan";
test.age = 88;
test.sex = "nan";
test.id = {1,2,3,4};
1
2
3
4
5
6

3.结构体的嵌套初始化：

struct s1{
 char name[20];
	int age;
};
struct s2{
	int num;
	struct s1* p1;
	char id[20];
}s1 = {100,{"wangwu",888},{5,4,3,2,1}};//结构体嵌套初始化
int main()
{
	struct s2 s = {188,{"zhangsan",999},{1,2,3,4,5}};//结构体嵌套初始化
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

结构体的自引用：

struct Node
{
int data;
struct Node next;
};   //错误
//无法计算sizeof(struct Node)的大小！

正确的方式：
struct Node{
int date;
struct Node* next;
};//   正确
//总结:结构体的自引用应借助结构体指针来完成;
1
2
3
4
5
6
7
8
9
10
11
12
13

结构体内存对齐：

struct s1 {
	char c1;
	int i;
	char c2;
};
struct s2 {
	int i;
	char c1;
	char c2;
};
printf("%d\n", sizeof(struct s1));//结果为   12
	printf("%d", sizeof(struct s2));//结果为   8
//这里我们就要思考为什么变量类型都是一样的计算的大小不一样呢？
//这就是结构体中内存对齐的知识
1
2
3
4
5
6
7
8
9
10
11
12
13
14

我们先来了解下，结构体中内存对齐的规则：

1. 第一个成员永远在在相较于结构体变量偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。对齐数 = 编译器默认的一个对齐数与 该成员大小的较小值。VS中默认的值为8。Linux中没有默认对齐数，对齐数就是成员自身的大小。
3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整
   体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

代码实例：

struct s1 {   自身大小   默认对齐数    对齐数    最大对齐数：4
	char c1;      1         8              1
	int i;        4         8              4
	char c2;      1         8              1
};
struct s2 {   自身大小   默认对齐数    对齐数    最大对齐数：4
	int i;        4          8            4
	char c1;      1          8            1
	char c2;      1          8            1
};
1
2
3
4
5
6
7
8
9
10

图解：

内存对齐的原因：

1.平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2.性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访。
总体来说：结构体的内存对齐是拿空间来换取时间的做法。
那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：
让占用空间小的成员尽量集中在一起。

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

S1和S2类型的成员一模一样，但是S1和S2所占空间的大小有了一些区别。

结构体传参

print1好? 还是print2好？

#include<stdio.h>
struct S
{
	int date[100];
	int num;
};
struct S s = { {1,2,3,4},10000 };
void print1(struct S S)
{
	printf("%d\n", s.num);
}
void printf2(struct S* ps)
{
	printf("%d\n", ps->num);
}
int main()
{
	print1(s);
	printf2(&s);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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

位段：

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

typedef struct stu {
	int  _a : 2;
	int _b : 3;
	int _c : 4;
	int _d : 5;
}stu;
int main()
{
	printf("%d\n", sizeof(stu));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

运行结果：

位段的内存分配：（站在节省内存的角度来看的）

1.位段的类型可以是 int /signed int /unsigned int /char (属于整型家族）类型。
2.位段的空间是按照需要以四个字节(int )或一个字节（char)的方式来开辟的。
3.位段涉及许多不确定因素，位段是不跨平台的，注意可移植的程序应避免使用位段。

#include<stdio.h>

	struct S {
		char _a : 4;
		char _b : 5;
		char _c : 2;
		char _d : 1;
	};
	int main()
	{
		struct S s= { 0 };
		s._a = 10;
		s._b = 3;
		s._c = 5;
		s._d = 3;
		return 0;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

图解：

枚举

枚举的定义：

enum Day {
	Mon,
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sun,
};
enum Sex {
	MALE,
	FFMALE,
	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

2.枚举的优点

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

联合体

联合体定义：

union Un
{
	char c;
	int i;
};
int main()
{
	//联合体变量的定义
	union Un un;
	//计算联合体变量的大小
	printf("%d\n", sizeof(un));
	return 0;
}

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

运行结果：

联合体的特点：

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

union Un {
	char c;
	int i;
};
int main()
{
	union Un un;
	printf("%d\n", &(un.i));
	printf("%d\n", &(un.c));
	un.i = 0x11223344;
	un.c = 0x55;
	printf("%x\n", un.c);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果：

联合体大小的计算

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

union un1 {
	char c[5];
	int i;
};
union un2 {
	short c[5];
	int i;
};
int main()
{
	printf("%d\n", sizeof(union un1));
	printf("%d\n", sizeof(union un2));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果：