C深剖关键字（5）

目录

一：union关键字

二：enum关键字

三：typedef关键字

---

一：union关键字

联合关键字：联合体内部共享空间，整个union的大小由内部最大的元素决定。

#include<stdio.h>
union un
{
	int a;
	char b;
	// a和b共用一个空间，不过空间总大小由a决定
};
int main()
{
	// a和b共用一个空间，不过空间总大小由a决定
	printf("%d\n", sizeof(union un)); // 4
	return 0;
}

联合体的访问和结构体类似都可以采用 . 操作符或 -> 指向操作符。

union un x;
x.a = 10;
union un* p = &x;
p->a;

union 的空间布局问题：

联合体的空间开辟由元素最大的为准，在这里由a决定。四字节，那b占用的是a的低地址处还是高地址处呢？

任何变量在开辟空间的时候，这个变量开辟后都有地址，这个地址一定是众多字节中最小的

我们将联合体变量的地址和联合体内最大元素的地址打印出来看看：

不难看出，在数值大小上是一样的

对于b来说，在申请空间的时候，所有的空间申请都是由较低地址处向上开始分配的，所以b是在最低地址开始的，换言之，内部成员b开辟的空间和联合体本身和a变量的地址值是一样的。

 结论：

联合体内所有成员的起始地址都是一样的，每一个都是第一个元素。

b永远在a的低地址处！！！

 利用联合体的空间分布可以巧妙判断出大小端：

这里要把一组二进制序列 0x 00 00 00 01保存在a对应的空间里，此时四个字节每个都有地址，而地址具有高低之分，而我们的数据按字节对应的1bit位进行划分的时候，数据就有高低权值位之别，所以存储方案有两种，一种高权值位放在高地址处，低权值低地址处，如我们上图的左边存法，01放在低地址处，第二种方案相反，如上图右边将01放在高地址处，因为b永远在a的低地址处，b占一个字节，如上图x.b=1红色记号笔划分出，如果存储方案是第一种，那么b=1,如果是第二种，那么b=0,而第一种存储方案正式小端的存储法则，第二种正是大端的存储法则。

如代码展示：

#include<stdio.h>
union un
{
	int a;
	char b;
};
int main()
{
	union un x;
	x.a = 1;
	if (x.b == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}

 

 注意：联合体的整大小必须能整除联合体内任何一个元素的大小

#include<stdio.h>
union un
{
	int a;
	char b[5];
};
int main()
{
	printf("%d\n", sizeof(union un)); // 8
	return 0;
}

根据我们之前的认知，联合体空间由最大元素决定，b的大小是5，按理来讲联合体大小应该是5，但运行起来大小却是8，联合体的整大小必须能整除联合体内任何一个元素的大小

 再看一段代码：

体现联合体和大小端的对应关系：

#include<stdio.h>
union un
{
	int i;
	char a[4];
}*p, u;
int main()
{
	p = &u;
	p->a[0] = 0x39;
	p->a[1] = 0x38;
	p->a[2] = 0x37;
	p->a[3] = 0x36;
	printf("0x%x", p->i); //0x36373839
	return 0;
}

二：enum关键字

enum枚举关键字作用：枚举一堆的常量，内部的常量直接可以被当作数据使用，枚举本身也是新增或设计了一种类型，换言之，我们可以使用枚举类型直接定义变量。如下：

#include<stdio.h>
enum color
{
	RED,
	YELLOW,
	BLACK,
	GREEN,
	BLUE
};
int main()
{
	enum color c = RED;
	printf("%d\n", RED); // 0
	printf("%d\n", BLACK); // 2
	printf("%d\n", BLUE); // 4
	return 0;
}

枚举出来的本质就是整数，对应的就是某种字面值，不可被修改的，所以RED,BLACK,BLUE就是真正意义上的常量

为什么要存在枚举？

1：现实世界中，有一大堆具有相关性的常量需要被在代码中体现出来。

2：一旦我们枚举常量之后，所有常量的常量名不是数字而是直接用英文单词去代表，这样写出来的代码具有自描述性。    

枚举常量的设定：

如果将第一个枚举常量的内容赋予一个特定的数字，那么后续的枚举常量会呈现加1式的递增，也可以分段式递增：

#include<stdio.h>
enum color
{
	RED=10,
	YELLOW,
	BLACK=-9,
	GREEN,
	BLUE
};
int main()
{
	enum color c = RED;
	printf("%d\n", RED);   // 10
	printf("%d\n", YELLOW);  // 11
	printf("%d\n", BLACK);  // -9
	printf("%d\n", GREEN);  // -8
	printf("%d\n", BLUE);   // -7
	return 0;
}

三：typedef关键字

本质：类型重命名。

#include<stdio.h>
//(1)
// 对结构体类型进行重命名
typedef struct stu {
	char name[16];
	int age;
	char sex;
}stu_t;

//(2)
//对unsigned int 重命名 u_int 简化
typedef unsigned int u_int;

//(3)
//对指针int*重命名
typedef int* int_p;

//(4)
typedef int a[10];  // 此刻a相当于一种数组类型
int main()
{
	u_int x = 0;
	int_p p = NULL;
	stu_t s;
	a b;
	return 0;
}

类型重命名，可以对一些不太好理解的数据类型进行简化。

但是也不是说typedef可以随便的重命名，如果对指针或者数组进行重命名的时候，那么使用的时候，就会忽略一些细节。比如说数组的元素有几个，类型是什么，指针是几维指针，什么类型的指针。过度的typedef本质其实变相就是一种让人困扰的东西，但是比较推荐大家在结构体的时候运用typedef关键字

 typedef和#define的区别

先看代码：

此段代码用的是typedef

#include<stdio.h>
typedef int* int_p;
int main()
{
	//int* a, b;
	// 此时a为指针，b为int 整型类型
	//int* a = NULL, b = 0; //可读性太差
	int_p a, b;
	// 此时a 和 b均为指针，等价于int* a, * b;
	return 0;
}

千万不要把typedef类型重命名看作某种替换，不能直接把int_t理解为int*,二者不能直接替换。而应将int_t理解成一种全新的类型，所以就不存在*会和a先结合还是和b先结合的问题。这个*的类型会对其后的所有定义的变量全部起效，int_p就作为一种独立类型去使用。

再来用#define试试

#include<stdio.h>
#define ptr_t int*
int main()
{
	ptr_t a, b, c;
	//等价于
	int* a, b, c;
	//a为int*, b和c均为int;
	return 0;
}

结论：

typedef类型重命名，并不是本质的文本替换，形成了一个新的独立的类型

宏define做的是纯纯文本替换

案例：

#include<stdio.h>
#define INT32 int
typedef int int32;
int main()
{
	unsigned INT32 a; 
	//因为宏define是文本替换，所以INT32就相当于int,所以就是ungsigned int a;
	//unsigned int32 b; 代码报错
	return 0;
}

问题：typedef static int int32_t 行不行？

 从图中很容易看出是不行的，此时编译器出错。

在32个关键字中，有五个存储类型关键字：

而存储类型关键字有个特点：

存储关键字，不可以同时出现，也就是说，在一个变量定义的时候，只能有一个。

所以typedef和static这两个关键字不能同时出现，所以上述代码会报错。