C语言之自定义类型------枚举和联合体

枚举：

举例：

下述为一个关于性别的枚举实例：

enum Sex
{
	//枚举的可能取值
	MALE,
	FEMALE,
	SECRET
};
1
2
3
4
5
6
7

打印枚举默认值：

#include
enum Sex
{
   //枚举的可能取值
   MALE,
   FEMALE,
   SECRET
};
int main()
{
   enum Sex s = MALE;
   enum Sex s1 = FEMALE;
   enum Sex s2 = SECRET;
   //根据初始化枚举变量打印默认值
   printf("%d ", s);
   printf("%d ", s1);
   printf("%d\n", s2);
   //根据枚举常量打印默认值
   printf("%d %d %d",MALE,FEMALE,SECRET );
   return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

输出结果：

0 1 2
0 1 2
1
2

结论：枚举的可能取值的默认值是从0开始。

修改默认值：

enum Sex
{
	//修改枚举常量的默认值
	MALE=9,
	FEMALE=7,
	SECRET=2
};
1
2
3
4
5
6
7

此时运行上述的main函数，输出结果为：

9 7 2
9 7 2
1
2

既然枚举常量的默认值可被修改，那么能否实现在mian函数中给它重新赋值呢？

int main()
{
	enum Sex s = MALE;
	enum Sex s1 = FEMALE;
	enum Sex s2 = SECRET;
	MALE = 19;//尝试修改枚举常量的值
	printf("%d %d %d",MALE,FEMALE,SECRET );
	return 0;
}
1
2
3
4
5
6
7
8
9

此时，编译并没有通过，报错如下所示：

说到这里很多小伙伴就会产生疑惑，为什么第一种能够进行修改呢？

原因是：第一种并不是修改枚举常量的值，而是给它赋初值，而第二种是对常量进行修改，但常量是不能被修改的。

修改部分枚举常量的默认值：

#include
enum Sex
{
	//修改部分枚举常量的默认值
	MALE=9,
	FEMALE,
	SECRET=2
};
int main()
{
	enum Sex s = MALE;
	enum Sex s1 = FEMALE;
	enum Sex s2 = SECRET;
	printf("%d %d %d",MALE,FEMALE,SECRET );
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出如下：

9 10 2
1

枚举常量FEMALE并没有赋初值，因此他会延续上一个枚举常量的值的之后的数，而SECRET，我们对他进行赋值，他不会继续沿用，而是输出给它赋值的默认值。

避免不同类型的赋值：

举例：

#include
enum Sex
{
	MALE=9,
};
int main()
{
	enum Sex s =5;//尝试给枚举类型变量赋整形数值
	printf("%d",MALE);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

当在c++文件中运行时：

编译未通过，报以下错误：

当在c语言文件中运行时：
编译通过，输出结果如下：

9
1

虽然c文件没有检测出来这个错误，但是我们也要避免犯这种错误。

对于常量的定义，我们也可以使用#define，那么为什么要使用枚举呢？

下面我们就来谈谈枚举的优点！

枚举的优点：

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

2：和define定义的标识符比较，枚举有类型检查，更加严谨

3：防止了命名污染（封装）

4：便于调试

当进行调试的这个过程，已经进入可执行程序阶段，如果使用#define定义常量，此时编译器已经完成了常量的值的替换，而我们所看到的还是未替换的，这样一来，使我们在调试的这个过程中需要不停的去查看这个常量对应的值，因此，增加了调试的难度。

5：使用方便，一次可以定义多个常量

枚举类型大小的计算：

举例：

#include
enum Sex
{
	Male,
	Falmale,
};
int main()
{
	enum Sex s=Male;
	printf("%d\n", sizeof(s));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

输出如下：

4//与整形大小一致
1

联合体：

联合体的定义：

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

举例：

#include
union S
{
	char c;
	int i;
};
int main()
{
	union S s;
	printf("%d ", sizeof(s));
	printf("%p ", &(s));
	printf("%p ", &(s.c));
	printf("%p ", &(s.i));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出如下所示：
我们会发现联合体s和它里面的成员的地址相同，也就是说他们公用一片空间。

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

联合体中的成员不能同时使用：

#include
union S
{
	char c;
	int i;
};
int main()
{
	union S s;
	s.i = 20;
	s.c = 10;
	printf("%d ", sizeof(s));
	printf("%d ",s.c);
	printf("%d ", s.i);
	printf("%p ", &(s));
	printf("%p ", &(s.c));
	printf("%p ", &(s.i));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输出结果如下所示：

在程序中，我们给联合体中的两个成员变量分别赋不同的值，但是输出结果输出的并不是我们赋予的不同值，而是都输出了后面赋值的成员变量值，原因是：联合体中的成员共用一块内存空间，如果我们同时修改两个成员的值，会出现内存都发生改变，这显然不符合联合体的特点，因此，我们在使用联合体成员的时候，应避免同时使用多个成员。

使用联合体判断大小端：

我们先来回忆一下我们之前学过的判断当前平台模式的方法：

大端：低位存高地址，低位存高地址
小端：低位存低地址，高位存高地址

举例：

#include
int main()
{
	int i = 1;
	if (*(char*)&i == 1)//将整形地址化成字符型地址再对其进行解引用
		printf("小端");
	else
		printf("大端");
	return 0;
}
1
2
3
4
5
6
7
8
9
10

小端
1

那么用联合体如何表示呢？

#include
union S
{
	char c;
	int i;
};
int main()
{
	union S s;
	s.i = 1;
	if (s.c== 1)//将整形地址化成字符型地址再对其进行解引用
		printf("小端");
	else
		printf("大端");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

小端
1

分析如下所示：

联合体大小的计算：

联合体的大小至少是最大成员的大小

当最大成员不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍

举例：

#include
union Un
{
	int a;
	char arr[5];
};
int main()
{
	union Un u;
	printf("%d\n", sizeof(u));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

8
1

分析如下：