C语言进阶——数据的存储

一，整形在内存中的存储

1.1 类型的基本归类

C语言中类型有很多，基本归为下面这几类

整形家族

#char:unsigned char，signed char

#short:unsigned char，signed char

#int:unsigned char，signed char

#long:unsigned char，signed char

浮点数家族

float，double 

 构造类型

数组类型：arr[]

结构体类型：struct

枚举类型：enum

联合类型：union

 指针类型

int *pi，char* pc，float* pf，void* pv

 空类型

void表示空类型，通常用于函数的返回类型，函数的参数，指针类型等，在后续学习中会经常见到

1.2 原码,反码,补码

计算机中有符号数有三种表示方法，即原码，反码，补码，三种表示方法均有符号位和数值位两部分，符号位位于最开头，0表示“正”，1表示“负”

原码：直接将二进制按照正负数的心事翻译成二进制

反码：原码的符号位不变，数值位依次按位取反

补码：反码+1就得到了补码

void main1()
{
	int num  = 10;//创建一个整型变量，叫num，这时num向内存申请4个字节来存放数据
	//4个字节-32比特位
	//00000000000000000000000000001010 - 原码
	//00000000000000000000000000001010 - 反码
	//00000000000000000000000000001010 - 补码

	int num2 = -10;
	//10000000000000000000000000001010 - 原码
	//11111111111111111111111111110101 - 反码
	//11111111111111111111111111110110 - 补码
}

正数的原码，反码，补码相同 

1.3 为什么数据存放时放的都是补码？

在计算机系统中，数值一律用补码来表示和存储，这样有几个好处

①使用补码，可以将符号位和数值统一处理

②CPU只有加法器，使用补码可以将加法和减法统一处理

③补码和原码相互转换，其运算过程时相同的，不需要额外的硬件电路

计算1-1
1+(-1)
使用补码计算正确
00000000000000000000000000000001 --> 1的补码
11111111111111111111111111111111 --> -1的补码
00000000000000000000000000000000
 
原码计算是错误的
00000000000000000000000000000001
0000000000000000000000000000001
0000000000000000000000000000010 --> -2

1.4 通过练习熟悉原反补码

补充知识点：

#①如果用char类型存储整形，会发生截断现象，

#②如果用%d打印char类型(8位)，会补全位数，有符号的按第一位数补全至32位，无符号的在前面用0补全

#③%d是十进制的形式打印有符号整形整数，如果打印的值不是整形会发生整形提升；%u是以十进制打印无符号数

#④有符号char类型可以表示的范围为-128 -- 127，无符号char范围为0 -- 255

#⑤说再多也没用，直接上代码，具体的内容已在代码中以注释的形式给出

void main2()
{
	char a = -1;
	//10000000000000000000000000000001
	//11111111111111111111111111111110
	//11111111111111111111111111111111 -->截断
	//11111111 -->a
	//11111111111111111111111111111111 -->打印时整形提示，补全
	//11111111111111111111111111111110 -->转为反码
	//10000000000000000000000000000001 -->再按位取反转为原码，值为-1

	signed char b = -1;
	//和上面一样

	unsigned char c = -1;
	//11111111 -->发生截断
	//00000000000000000000000011111111 -->由于是unisgned无符号，所以用0补全，如果不是无符号，按第一个数字补全
	//11111111就是255

	printf("a=%d,b=%d,c=%d", a, b, c);
	//%d - 十进制的形式打印有符号整型整数
	//整型提升
	//打印-1,-1,255
}

void main3()
{
	char a = -128;
	//10000000000000000000000010000000 -->-128的原码
	//11111111111111111111111101111111 -->反码
	//11111111111111111111111110000000 -->补码
	//由于是char类型，发生截断
	//a里面存的是10000000
	printf("%u\n", a);
	//打印时整形提升
	//11111111111111111111111110000000
	//%u是以十进制无符号数打印，打印4294967168

	//当a=128时结果也一样，因为截断时截断相同的位
}

void main4()
{
	int i = -20;
	//10000000000000000000000000010100
	//11111111111111111111111111101011
	//11111111111111111111111111101100

	unsigned int j = 10;
	//00000000000000000000000000001010 -->无符号数，原反补相同，10的补码
	//11111111111111111111111111101100 -->-20的补码
	//11111111111111111111111111110110 -->上面两个相加的结果
	//11111111111111111111111111110101 -->上面的补码-1后的反码
	//10000000000000000000000000001010 -->上面补码的原码，结果为-10
	printf("%d\n", i + j);

	//补码转化为原码，除了-1后取反，还可以取反后+1
	//11111111111111111111111111110110 -->上面两个相加的结果
	//10000000000000000000000000001001 -->取反
	//10000000000000000000000000001010 -->加一，结果也是-10
}

#include<windows.h>
void main5()
{
	unsigned int i;
	for(i = 9; i >= 0; i--)
	{
		printf("%u\n", i);
        //先从9打印到0，由于是无符号，不会打印-1，而是打印最大整形数4294967295，然后再递减
		Sleep(1000);//单位是毫秒
	}
}

void main6()
{
	char a[1000];
	int i;
	for (i = 0; i < 1000; i++)//0 -- 999
	{
		a[i] = -1 - i;//
	}
	//由于数组是char类型，所以其实不是和我们想的那样把-1到-1000原原本本存进去，是像下面这样的
	//-1,-2,-3 ... -128,-127,-126 ... 3,2,1,0 然后又从-1开始依次循环，直到存够1000个数
	
	//strlen是求字符串长度的，返回\0之前出现数字的个数，\0的ASCII码值是0，所以打印255
	printf("%d", strlen(a)); 
}

void main7()
{
	unsigned char i = 0;
	//死循环打印，因为i的范围是0到255，这个for需要到256才能停下，但是255+1后就变成了0，死循环
	for (i = 0; i <= 255; i++) 
	{
		printf("hello world\n");
	}
}

二，大端和小端字节序存储模式

2.1 什么是大端，小-端

大端存储模式：数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址中

小端存储模式：数据的低位保存在内存的低地址中，而数据的高位,，保存在内存的高地址中

为什么会有大小端模式之分呢？这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一 个字节，一个字节为8bit 。但是在 C 语言中除了 8bit 的 char 之外，还有 16bit 的 short 型， 32bit 的 long 型（要看具 体的编译器），另外，对于位数大于8 位的处理器，例如 16 位或者 32 位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如果将 多个字节安排的问题 。因此就导致了大端存储模式和小端存储模式。

2.2 通过程序判断大小端

void main8()
{
	int a = 1; //假设为小端，则为0x01000000，大端为0x00000001
	char* p = (char*)&a;//&a类型为int*，强转为char*,发生截断只存了第一个00或者01，然后下面对*p进行解引用，如果为1就是小端，为0就是大端
	if (*p == 1)
		printf("小端\n");
	else
		printf("大端\n");
}

也可以通过函数判断，原理和上面大致相同

int check_sys()
{
	int a = 1;
	if (*(char*)&a == 1)
		return 1;
	else
		return 0;
}

void main9()
{
	if(check_sys())
		printf("小端\n");
	else
		printf("大端\n");
}

三，浮点型在内存中的存储

3.1 一个现象

先看下列代码

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

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

正常情况下，应该会打印9，9.0，9，9.0，但是真实情况却是这样的

 这说明什么，说明打印9，9.0，9，9.0的压根就不是正常情况鸭，不急，对于浮点数的存储大有文章，咱们慢慢看

3.2 浮点数存储规则

通过上面的现象我们可以得出一个结论：浮点数和整数有着不同的存储规则

根据国际标准IEEE（电器和电子工程协会）754，任意一个二进制浮点数（假设为V）都可以表示为下面的形式:

V = (-1)^S * M * 2^E

 咱先不来看这个式子，先看下小数在内存中咋存的

比如十进制的5.0，写成二进制就是101.0，如果是5.5，那么二进制就是101.1，因为小数位后面的数是单独存的，0.5=1/2，也就是2^-1，所以0.5按二进制存储时就是0.1

所以对于5.0，写成二进制就是101.0，相当于1.01*2^2,所以根据上面的式子可以将V = (-1)^0 * 1.01 * 2^2,所以我们就知道了S代表位数，M=1.01，E=2，而且由这个式子我们也知道了，任何浮点数都可以用这个式子表示，所以对于浮点数的存储，我们只需要存S，M和E这三个数就可以了

 IEEE 754规定：对于32位的浮点数，最高的1位是符号位s，接着的8位是指数E，剩下的23位为有效数字M。

对于 64 位的浮点数，最高的 1 位是符号位 S ，接着的 11 位是指数 E ，剩下的 52 位为有效数字 M 。

 在存储M的时候，由于默认M的第一位是1，因此可以将其舍去，只保留后面的部分，比如存储1.01的时候只存01，等到读取的时候，再把第一位的1加上去。这样做的目的，是节省1位有效数字。 以32位浮点数为例，留给M只有23位，将第一位的1舍去以后，等于可以保存24位有效数字

 然后对于指数E的情况有点复杂，首先，E定义为一个无符号整数，32位下取值范围为0-255之间，64位下位为0-2047。但是在存0.5的时候，0.5用上面的式子表示就是V = 0.1 = (-1)^0 * 1.0 * 2^-1，咦，你不是告诉我E是无符号整数吗，这这这怎么出现了负数，此时你的认知开始损坏，眼睛开始呆滞，开始怀疑自己。。。。停！有解决办法！

所以我们知道了E可能会出现负数，然后我们聪明的先辈为了解决这个问题，在存入E的真实值的时候需要加上一个中间值，对于8位数的E，存的时候加上127；对于11位的E，存的时候加上1023.比如2^10的E是10，存的时候要加上127，也就是137，即10001001。

然后对于指数E还分为下面几种情况 

#①E不全为0或不全为1：这时，浮点数就采用下面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将有效数字M前 加上第一位的1。 比如： 0.5的二进制形式为0.1，由于规定正数部分必须为1，即将小数点右移1位， 则为1.0*2^(-1)，E为-1，其存的时为-1+127=126，表示为01111110，而尾数1.0去掉整数部分为0，补齐0到23位 0000 0000 0000 0000 0000 000，则其二进制表示形式为 0 01111110 0000000000000000000000

 #②E全为0：这时，浮点数的指数E等于1-127（或者1-1023）即为真实值， 有效数字M不再加上第一位的1，而是还原为 0.xxxxxx的小数。这样做是为了表示±0，以及接近于0的很小的数字。后面解释现象时会有实例说明

#③E全为1：这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）

void main10()
{
	float f = 5.5;
	//101.1 二进制浮点数
	//V = 101.1 = (-1)^0 *1.011 * 2^2
	//S=0,M=1.011,E=2
	// 2+127位129为10000001,然后后面存011后面补零，就变成了下面这样
	// 0 10000001 011(补零)00000000000000000000
	// 然后以16进制显示就是下面这个
	//0100 0000 1011 0000 0000000000000000  换为十进制就是下面这个
	// 4    0    b    0    0000   合起来就是下面这个了
	//0x40b00000
}

 

 3.3 解释上面的现象

void main11()
{
	int n = 9;
	//0 00000000 00000000000000000001001 -->9的二进制序列
	printf("n的值为：%d\n", n);//9，没问题

	float* pFloat = (float*)&n;
	//当以浮点去访问整数9的时候，任然以上面两个图的方式来搞
	//0 00000000 00000000000000000001001 -->9的二进制序列
	//S  E        M             E全为0，减去126
	//0  -126     0.00000000000000000001001
	//(-1)^0 * 0.00000000000000000001001 * 2^-126 -->最后结果就是这个样子
	//可以看到上面弄出来后是一个非常非常小的数字，%f打印时只读取前面6位，所以打印0.000000
	printf("*pFloat的值为：%f\n", *pFloat);//0.000000

	*pFloat = 9.0;
	//1001.0
	//V = 1001.0 = (-1)^0 * 1.001 * 2^3
	//S=0     E=3          M=1.001           3存的时候加127就是130，二进制序列就是10000010
	//0      10000010   001(补零)00000000000000000000
	//以%d打印时，最高位是0，原反补相同，所以直接把上面的二进制转化为十进制打印出来，就是1091567616
	printf("num的值为：%d\n", n);//1091567616
	printf("*pFloat的值为：%f\n", *pFloat);//9.000000
}