这一讲分别介绍了整数和浮点数在内存中的存储方式，以及一些题目的解析

1.整数在内存中的存储

1.1存储方式

数据在内存中的存储都是以其二进制位来表示的，而整数的二进制位的表示方法有三种：原码、反码、补码，在内存中，存储的是正数的补码
正数的原码、反码、补码相同
负数的三种表示方式各不相同
那么为什么整数存储的是补码呢？

1.CPU只有加法器，使用补码能够将字符位和数值位统一处理
2.原码和补码进行转换的过程是相同的，不需要额外的硬件电路便可以实现

1.2大小端字节序

当我们对于一个整数变量进行内存监视时，常常会观察到整数的存放顺序和我们创建的变量值顺序是不同的，例如：

当我们创建了一个a变量时，它在内存中的存储为（VS编译器）：

可以看见，它是倒着存的，不是正着存的，这就涉及到了整数存储顺序的两种方式：大端存储和小端存储

1.3大小端字节序排序规则

大端排序方式：

低位的字节放在高地址，高位的字节放在低地址

小端排序方式：

低位的字节放在低地址，高位的字节放在高地址

我们画图来解析：

1.4为什么要有大小端

我们常⽤的 X86 结构是⼩端模式，⽽KEIL C51 则为⼤端模式。很多的ARM，DSP都为⼩端模式。有些ARM处理器还可以由硬件来选择是⼤端模式还是⼩端模式。

但是为什么要有着大小端的存在呢？

1.C语言有着多种类型的数（float、 int、char），对于字节安排的问题，必然要被得到处理
2.不同的硬件设计可能导致不同的存储方式，硬件的设计使用某种存储方式可能会优化性能或简化设计
3.不同的存储方式可能对性能有不同的影响

1.5练习

总结：
1.整数在运算时（整型提升、加法、减法）都是补码在进行运算
2.对于整数的打印，分为两种情况：

1.打印有符号整数，如果需要整形提升，那么补的是符号位，将补码转换成原码，进行计算之后将得出值进行打印
2.打印无符号整数，如果需要整形提升，如果最高位为1，补1，为0，补0，和有符号整数相同，但是计算结果时看的是补码，因为无符号整数的原码、反码、补码相同

1.5.1练习1

//设计⼀个⼩程序来判断当前机器的字节序。
//
//设计思路：
//创建一个a变量，赋值为1，其在内存中的存储应该为00 00 00 01
//①如果为小端存储：存储方式应该为01 00 00 00
//②如果为大端存储：存储方式为00 00 00 01
//分别拿出它们首个字节，如果值为1，就是小端存储，如果值位0，就为大端存储
//
//代码1：
int main2()
{
	int a = 1;

	if (*((char*)&a))  //注意：这里为&a，因为只能将地址强转成（char*）类型的指针，否则可能会出现越界访问
		printf("小端存储\n");
	else
		printf("大端存储\n");
	return 0;
}

//代码2：
int DefA()
{
	int a = 1;
	return *((char*)&a);
}

int main()
{
	int ret = DefA();

	if (ret)
		printf("小端存储\n");
	else
		printf("大端存储\n");
	return 0;
}

1.5.2练习2

//1.5.2练习2
int main()
{
	char a = -1;//对于char类型的变量，它可能时signed char类型，也可能是unsigned char类型，具体取决于编译器，这里是有符号类型
	//char类型为一个字节，此时，-1的2进制表示为10000001，它的补码为：11111111
	//因为-1为整形，所以它的补码结果为：11111111111111111111111111111111，而a为char类型，char类型只能存储11111111，所以对于a：
	//补码：11111111，由于要进行打印，发生整形提升，结果为11111111111111111111111111111111
	//原码：10000000000000000000000000000001
	//所以结果为-1
	signed char b = -1;
	//char类型在此编译器下就是有符号类型的，所以对于有符号类型的char分析和上面一样
	//所以结果为-1
	unsigned char c = -1;
	//对于无符号类型，仍为1个字节，所以a还是11111111
	//整型提升结果为00000000000000000000000011111111，因为对于无符号整形，整形提升加0
	//此时符号位为0，所以原码和补码相同，计算的结果为255

	printf("a=%d,b=%d,c=%d", a, b, c);
	//以%d形式打印，表示打印有符号整数
	return 0;
}

1.5.3练习3

//1.5.3练习3
int main()
{
	char a = -128;
	//-128，原码为10000000000000000000000001000000，反码为11111111111111111111111110111111，补码为11111111111111111111111111000000
	//所以a里存的是11000000
	//要打印的是无符号整形，进行整形提升，结果为11111111111111111111111111000000
	//所以结果为4294967168
	printf("%u\n", a);
	return 0;
}

1.5.4练习4

//1.5.4练习4
int main()
{
	char a = 128;
	//对于128，它的原码为00000000000000000000000010000000
	//反码：01111111111111111111111101111111
	//补码：01111111111111111111111110000000
	//存储到a里，结果为10000000
	//打印无符号整形，整形提升
	//补码：11111111111111111111111110000000
	printf("%u\n", a);
	return 0;
}

但是，看练习4，当我们要将128这个值存到char类型中时，a为10000000，这显然就是-128呀！这是因为char类型的取值范围为-128 - 127，128根本存不下，这时存储遵循一个规律：

所以我们可以将他们看成一个循环，对于其他类型的整数（float、int）也是如此

1.5.5练习5

//1.5.5练习5
#include <string.h>

int main()
{
	char a[1000];
	int i;

	for (i = 0; i < 1000; i++)
	{
		a[i] = -1 - i;
		//strlen是求字符串长度的函数，遇到\0会停止
		//对于一个char类型的数组，里面放的元素为char类型
		//而我们已经了解到了，char类型的取值范围为-128 - 127
		//所以a数组中放的值只能为：-1 -2 -3 ... -127 -128 127 126 ... 2 1 0这些ASCII码值对应的字符
		//遇到\0停止，所以结果为255
	}

	printf("%zd", strlen(a));
	return 0;
}

1.5.6练习6

//1.5.6练习6
unsigned char i = 0;

int main()
{

	for (i = 0; i <= 255; i++)
	{
		//无符号char类型的取值范围为0-255，所以会一直满足循环条件，会一直循环进行打印
		printf("hello world\n");
	}
	return 0;
}

#include <windows.h>

int main()
{
	unsigned int i;

	for (i = 9; i >= 0; i--)
	{
		//对于无符号int类型，他所有的位都会被当成数值位，所以它不会出现负数的情况
		//所以它会一直满足条件，一直进行打印
		printf("%u\n", i);
		Sleep(100);
	}
	return 0;
}

1.5.7练习7

//1.5.7练习7
//X86环境 ⼩端字节序
int main()
{
	int a[4] = { 1, 2, 3, 4 };
	int* ptr1 = (int*)(&a + 1);
	//&a取出的是整个数组的地址，+1表示紧挨着数组的那块地址，将其强转成int*类型的指针赋给ptr1
	//*（ptr-1）得到的就是4
	int* ptr2 = (int*)((int)a + 1);
	//a表示首元素的地址，将其转换成int类型，表示的是一个数！，+1表示地址加1，直接+1就可以了
	//但是要注意：每一个字节都有一个指针，+1表示的是向后偏移一个字节
	//对于a，在内存中的存储为0x 01 00 00 00 02 00 00 00 ...（因为为小端存储），向后偏移一个字节，就变成了：
	//00 00 00 02 00 00 00
	//对他解引用，访问4个字节，所以找到了00 00 00 02，因为为小端存储，所以结果为02000000

	printf("%x,%x", ptr1[-1], *ptr2);
	return 0;
}

2.浮点数在内存中的存储

2.1练习

浮点数的存储和整形的存储是不一样的，下面我们就通过一个练习来直观地感受一下：

//2.1练习
int main()
{
	int n = 9;

	float* pFloat = (float*)&n;
	printf("n的值为：%d\n", n);//9
	printf("*pFloat的值为：%f\n", *pFloat);//0.000000

	*pFloat = 9.0;
	printf("num的值为：%d\n", n);//1091567616
	printf("*pFloat的值为：%f\n", *pFloat);//9.000000
	return 0;
}

2.2浮点数的存储

既然知道了整形和浮点型的不同，那么浮点数是怎么存储的呢？

根据国际标准IEEE（电气和电子工程协会） 754，任意⼀个⼆进制浮点数V可以表示成下⾯的形式：

我们通过举例来说：

//2.2浮点数的存储
int main11()
{
	float a = 5.5;
	//我们来探讨5.5在内存中的存储形式：
	//5的二进制表示为101.1，写成科学计数法的形式为1.011 * 10^2
	//所以符号位S为0（因为为整数）
	//指数位E = 2
	//数值位为M = 1.011

	return 0;
}

如果没有看懂，我们通过图像来直观感受：

我们可以简单理解S、E、M这三个值如上

IEEE 745规定：
1.对于32位的浮点数，最高的一位存储的是符号位，接着八位存储指数E，剩下32位存储有效数字M
2.对于64位的浮点数，最高的一位存储的是符号位，接着十一位存储指数E，剩下52位存储有效数字M

2.3浮点数的存储过程

2.3.1符号位的存储

符号位的存储只占据一个字节，很简单，是正数就是0，是负数就是1

2.3.2对于有效数字M的存储

其实M的取值范围为1<=M<2，也就是说，M总是可以表示成1…的形式，所以IEEE 754规定，在计算机保存M时，只保存小数点后边的部分，前边的1舍去，等到读取的时候，再将1加上去，这样就节省了一位有效数字，使得精度更高，比如：1.01在进行存储时，只存储01，读取时再将1加上；0.10可以表示成1.0 * 10的负一次幂，所以说它在存储时存储0就可以了，需要注意的是：它要在后边补0，也就是说对于1.1，在存储时存储的是01000000000000000000000

2.3.3对于指数E的存储

对于指数的存储比较复杂，分为三种情况讨论：

2.3.3.1E不全为0或不全为1

因为E的值可能为负数，为了将负数表示出来，我们需要将E的值加上127（在32位机器上，偏移值为127，在64位机器上，偏移值为1023），再将其转换成二进制存储即可，这样即可以通过比较指数的大小来判断两个浮点数的大小关系，同时也可以方便地进行加减乘除等计算操作

这种情况为正常情况，比如0.5的二进制表示形式为0.1，也就是1.0 * 10的负一次幂，在存储数值位时要将数值位的一忽略，所以存储时存储的就是0，补齐23位，也就是00000000000000000000000，指数位值为-1，加上127为126，二进制表示为01111110，符号位为0，所以0.5的二进制表示为：

0 01111110 00000000000000000000000

2.3.3.2E全为0

当E全为0时，指数位的值为1-127（它是规定好的），而且此时数值位在进行复原时，补的不是1了，而是0，此时表示的是一个无限接近于0的一个小数

2.3.3.3E全为1

这时表示的是一个无穷大的数

2.4题目解析

//2.4题目解析
int main()
{
	int n = 9;

	float* pFloat = (float*)&n;
	printf("n的值为：%d\n", n);
	//n本来就是一个int类型的数，进行打印，结果为9
	printf("*pFloat的值为：%f\n", *pFloat);
	//对于9：
	//原码：00000000000000000000000000001001
	//对于一个float类型的数，因为要解引用，拿到的是原码：
	//符号位：0 - 正数
	//数值位：00000000000000000001001 - 0.00000000000000000001001
	//指数位：00000000 - 原码为00000000 - 1-127 = -126
	//所以值为0.00000000000000000001001 * 10的-126次幂
	//他表示0.0000000000000000000...1001是一个很小的数
	//尽管要拿出来，拿出的也只是0.000000，所以结果为0.000000

	*pFloat = 9.0;
	//9的二进制表示1001.0 - 1.001 * 10 ^ 3
	//符号位：0 - 正数
	//数值位：1.001 - 00100000000000000000000 - 注意：要在后边补0
	//指数位：3 + 127 = 130 - 10000010
	//全部 —— 0 10000010 00100000000000000000000 - 1,091,567,616
	printf("num的值为：%d\n", n);
	全部 —— 0 10000010 00100000000000000000000 - 1,091,567,616
	printf("*pFloat的值为：%f\n", *pFloat);
	//直接打印出9.000000即可
	return 0;
}