数据在内存中的存储

1. 整数在内存中的存储

在学习详解操作符（详解操作符-CSDN博客）的时候，我们知道：

整数的2进制表示方法有三种，即原码，反码，补码，有符号整数，三种表示方法中均有符号位和数值位，其中最高位为符号位，其余为数值位，符号位用“0”表示正数，“1”表示负数。

正整数的原码，反码，补码都相同；负整数的三种表示方法各不相同，具体操作见详解操作符-CSDN博客

对于整型来说：数据存储在内存中实际存放是二进制的补码。

这是因为：

在计算机系统中，数值一律用补码来表示和存储。 原因在于，使用补码，可以将符号位和数值域统一处理； 同时，加法和减法也可以统一处理（CPU只有加法）此外，补码和原码相互转换，其运算过程是相同的，不需要额外的硬件电路

1.1 无符号整数

无符号整数是指二进制中没有符号位，全是有效位，并且无符号整数的原码，反码，补码都相同。

2. 大小端字节序和字节序判断

在学习这块内容之前，我们先来看一段代码：

#include<stdio.h>
int main()
{
	int a = 0x11223344;

	return 0;
}

通过上面的图片中标红的地方，我们看出，在代码中，我们给a的地址是0x11223344，为什么在调试的时候就变成了44332211呢？这是为什么？

2.1 什么是大小端字节序

在内存中存储的时候，只要这个数据的大小超过一个字节，就会出现存储顺序的问题，按照不同的存储顺序，我们分为大端字节序和小端字节序：

大端字节序存储：将一个数据的低位字节的数据存储到高地址处，高位字节的数据存储到低地址处。

小端字节序存储：将一个数据的低位字节的数据存储到低地址处，高位字节的数据存储到高地址处

简单来说就是：小端字节序存储是倒序存储，大端字节序存储时正序存储

写到这里就有小伙伴会提出疑问？什么是低位字节，什么是高位字节，什么是低地址，什么是高地址？

先来看一下什么是低地址，什么是高地址？

那什么是低位字节，什么是高位字节？

十进制的123中，1是百位，2是十位，3是个位，百位相对于个位是高位，而个位相对于百位是低位，那我们是不是就可以得出：

如果是上面所显示的地址，那么大端字节序存储就是：11 22 33 44；

小端字节序存储就是：44 33 22 11

2.2 为什么有大小端？

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

简单来说就是，如果我存了四个字节的数据，需要拿出四个字节的数据，此时是不需要考虑大小端的问题，但如果需要拿出1个字节的数据，此时就需要考虑大小端的问题，因为拿1和0是不一样的

2.3 练习

2.3.1 练习1

设计一个小程序来判断当前机器的字节序。

void check_sys()
{
	int i = 1;
	if (*(char*)&i == 1)//这里的&为取地址操作符
	{
		printf("小端\n");
	}
	else
		printf("大端\n");
}
int main()
{
	check_sys();
	return 0;
}

1在内存中以16进制方式存储的地址是00 00 00 01，如果是大端字节序存储，那就是00 00 00 01，如果是小端字节序存储那就是01 00 00 00，观察上面的两种存储方式，我们发现，只要我们可以判断出最上面的一个字节所代表的数据是1（16进制的1也是1）还是0就可以判断出是大端存储还是小端存储。

2.3.2 练习2

int main()
{
	char a = -1;
	signed char b = -1;
	unsigned char c = -1;
	printf("a=%d,b=%d,c=%d", a, b, c);
	return 0;
}

在看这道练习之前，我们先来看看signed char 和unsigned char的取值范围：

signed char: -128~127; unsigned char :0~255

ok，接下来让我们来看这道题： char a = -1; 10000000000000000000000000000001 -1的原码 11111111111111111111111111111110 -1的反码 11111111111111111111111111111111 -1的补码 11111111 a中真实存的，这是因为一个char类型的变量中只能存放8个比特位，但-1的补码有32位比特位，所以此时就需要截断。 前面我们学习了，在进行算术运算之前，如果长度小于int的长度，就需要发生整型提升,整型提升要看这个数的类型。 a是signed char有符号char，要按照有符号整数的规则进行整型提升详解操作符-CSDN博客（提醒:最高位为符号位） 11111111111111111111111111111111 a提升后的(补码) %d是以十进制的形式打印有符号的整数(认为我们要打印的数据在内存中是以有符号数的补码进行存储的(我认为内存中的是有符号数的补码)) 11111111111111111111111111111111 a提升后的(补码) 10000000000000000000000000000001 a提升后的(原码） 打印结果为-1 signed char b = -1; b的情况与a一摸一样，这里就不过与论述 unsigned char c = -1; 10000000000000000000000000000001 -1的原码 11111111111111111111111111111110 -1的反码 11111111111111111111111111111111 -1的补码 11111111 c中真实存的，这是因为一个char类型的变量中只能存放8个比特位， 但-1的补码有32位比特位，所以此时就需要截断 c是unsigned char无符号char，要按照无符号整数的规则进行整型提升 00000000000000000000000011111111 c提升后的(补码)(最高位为0，表示正数) 00000000000000000000000011111111 c提升后的(原码) //打印结果为255

注意：系统认为char就是signed char

2.3.3 练习3

int main()
{
	char a = -128;
	printf("%u\n", a);
	return 0;
}

char a = -128; 10000000000000000000000010000000 a的原码 11111111111111111111111101111111 a的反码 11111111111111111111111110000000 a的补码 10000000 a中真实存的，这是因为一个char类型的变量中只能存放8个比特位，但-128的补码有32位比特位，所以此时就需要截断。 a是signed char是有符号的char,要按照有符号整数的规则进行整型提升（提醒:最高位为符号位） 11111111111111111111111110000000 a整型提升后的补码 %u是以十进制的形式打印无符号的整数(认为内存中存储的是无符号数的补码),这句话就说明了要将 11111111111111111111111110000000 a整型提升后的补码 认成是无符号数的补码 既然是无符号数的补码，无符号数没有符号位，全是有效位，原，反，补相同 打印结果为4294967168

int main()
{
	char a = 128;
	printf("%u\n", a);
	return 0;
}

char a = 128; 00000000000000000000000010000000 a的原码 00000000000000000000000010000000 a的反码 00000000000000000000000010000000 a的补码 10000000 a中真实存的，这是因为一个char类型的变量中只能存放8个比特位，但-128的补码有32位比特位，所以此时就需要截断 a是signed char是有符号的char,要按照有符号整数的规则进行整型提升 11111111111111111111111110000000 a整型提升后的补码 %u是以十进制的形式打印无符号的整数(认为内存中存储的是无符号数的补码)，通过这句话就说明了要将 11111111111111111111111110000000 a整型提升后的补码 认成是无符号数的补码 既然是无符号数的补码，无符号数没有符号位，全是有效位，原，反，补相同 打印结果为4294967168

2.3.4 练习4

#include<string.h>
int main()
{
	char a[1000];
	int i;
	for (i = 0; i < 1000; i++)
	{
		a[i] = -1 - i;
	}
	printf("%d", strlen(a));
	return 0;
}

char a[1000]; int i; for (i = 0; i < 1000; i++) { a[i] = -1 - i; } 通过前面的学习，我们知道a[i]中的内容应该是-1，-2，-3……-128，-129……-1000，但这真的对吗？char a[1000]说明了数组a中存放是char类型的数据，char就是signed char(有符号char),signed char的取值范围是-128~127,那-129，-130……-1000能放进去吗？答案是当然不行的，那这后面的数据该如何存放？ -129存放到char类型是01111111 127存放到char类型是01111111，哦呦，这两个在char类型中的存储简直就是一模一样，既然我们都是这样想的，那超过这个范围的数字，它就会按照char类型数据自己的读取方式进行存储 我们仔细观察下面这张图，会发现，内循环依次-1，哦呦，-1，-2，-3……-1000不也是依次-1嘛，好巧啊

这就说明了，内存中只能存入该范围内的数据，若数据不在此范围内，它会按照自己的读取方式进行存储 printf("%d", strlen(a)); strlen求的是\0之前的数据个数，\0的ASCII码值是0,所以最终打印的结果是255

2.3.5 练习5

unsigned char i = 0;
int main()
{
	for (i = 0; i <= 255; i++)
	{
		printf("hello world\n");
	}
	return 0;
}

通过前面的学习，我们知道unsigned char的取值范围是0~255,并且超过这个范围的数据会按照自己的存储方式，进行存储,回到循环代码中，既然我们知道unsigned char的取值范围是0~255,并且超过这个范围的数据会按照自己的存储方式进行存储,那i <= 255这个循环结束的判断条件就恒成立了，那这个循环就变成了死循环了。

int main()
{
	unsigned int i;
	for (i = 9; i >= 0; i--)
	{
		printf("%u\n", i);
	}
	return 0;
}

unsigned int的取值范围是>=0，既然unsigned int的取值范围是>=0,那是不是就说明了变量i>=0 回到循环代码，循环结束的判断条件是i>=0,正好与unsigned int的取值范围相同，那这个循环就变成了一个死循环

2.3.6 练习6

//x86环境 小端字节序
int main()
{
	int a[4] = { 1,2,3,4 };
	int* ptr1 = (int*)(&a + 1);
	int* ptr2 = (int*)((int)a + 1);
	printf("%x,%x", ptr1[-1], *ptr2);
	return 0;
}

int a[4] = { 1,2,3,4 }; int* ptr1 = (int*)(&a + 1); &a取出的是整个数组的地址，类型是int (*)[4],&a + 1跳过的是整个数组，类型是int (*)[4]。 (int*)(&a + 1)是将类型由int (*)[4]强制转换成int*， ptr1[-1]可以转换成*(ptr1-1),所以ptr1[-1]=4； %x是以16进制的形式打印,所以第一个打印结果是4。 int* ptr2 = (int*)((int)a + 1); 这里的a表示数组首元素的地址，(int)a将地址强制转换成int类型(也就是将以16进制形式打印出的地址转换成十进制(假如地址是0x00 00 00 01转换成十进制就是1))； (int)a + 1就是将刚刚转换出的十进制+1(1+1=2)；(int*)((int)a + 1)是将((int)a+1)的结果(比如:2)转换成16进制的地址(0x00 00 00 02)，我们看到0x00 00 00 01与0x00 00 00 02相差的是一个字节，那也说明了(int*)((int)a + 1)与a(这里表示首元素地址)相差一个字节，则ptr2就为下图中所表示的地址。 %x是以16进制的形式打印,所以*ptr2打印结果就是02 00 00 00(内存是以小端字节序存储,打印时需倒置顺序)

浮点数家族包括：float、double、long double类型。

在学习浮点数在内存中的存储之前，我们先来看一段代码：

#include<stdio.h>
int main()
{
	int n = 9;
	float* pFloat = (float*)&n;
	printf("n的值为:%d\n", n);
	printf("*pFloat的值为:%f\n", *pFloat);

	*pFloat = 9.0;
	printf("n的值为:%d\n", n);
	printf("*pFloat的值为:%f\n", *pFloat);
	return 0;
}

此代码输出什么？

编译器给我们这四个结果，这是什么原因呢？接下来让我们开始学习浮点数在内存中的存储。

3.1 浮点数的存储

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

比如十进制形式的浮点数：5.0，写成二进制是101.0，相当于：1.01*2^2，如果按照上面的标准形式，就可以写成：（-1）^0 *1.01*2^2。其中S=0,M =1.01,E=2。

IEEE 754规定：

对于32位的浮点数(float)，最⾼的1位存储符号位S，接着的8位存储指数E，剩下的23位存储有效数字 M

对于64位的浮点数(double)，最⾼的1位存储符号位S，接着的11位存储指数E，剩下的52位存储有效 数字M

3.1.1浮点数存的过程

3.1.1.1 有效数字M

IEEE 754对有效数字M和指数E，还有一些特别规定：

前面说过，1<=M <=2,也就是说，M可以写成1.xxxxxxx的形式，其中xxxxxxx表示小数部分。

IEEE 754规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的xxxxxxxx部分。比如在存储1.011的时候，只保存011，等到读取的时候，再把第一位的1加上。这样做的目的，时节省1位有效数字。若是32位浮点数，留给M只有23位，将第⼀位的1舍去以后，等于可以保存24位有效数字。 若是64位浮点数，留给M只有52位，将第⼀位的1舍去以后，等于可以保存53位有效数字。 （简单来说，在存储时不存小数点前面的1，只保存后面的小数位）

3.1.1.2指数E

至于指数E,情况就比较复杂

首先，E是一个无符号整数（unsigned int）

这意味着，如果E为8位，它的取值范围为0~255；如果E为11位，它的取值范围为0~2047。但是，我们知道，科学计数法中的E是可以出现负数的，所以IEEE754规定，存⼊内存时E的真实值必须再加上 ⼀个中间数，对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。

float E+127,然后再转换成二进制; double E+1023,然后再转换成二进制

⽐如， 2^10 的E是10，所以保存成32位浮点数时，必须保存成10+127=137，即10001001

注意：浮点数在内存中时无法精确保存的。

3.2 浮点数取的过程

3.2.1 指数E

指数E从内存中取出还可以再分成三种情况：

1、E不全为0或不全为1（常规情况）（有0也有1）： 指数E的计算值减去127（float）或者减去1023（double），从而得到真实值，再将有效数字M前加上第一位的1。

比如：0.5的二进制的形式位0.1，由于规定正数部分必须为1，所以要将小数点右移1位，则为1.0*2^-1,其中E就为-1+127=126，转换成二进制位01111110，而有效值M为去掉1.0的整数部位的1，保留小数点后面的部分，然后补齐23位：00000000000000000000000，（这里的补齐23位，是在0的后面补上0，直到23位）则0.5在内存中的二进制的存储形式就为：0 01111110 00000000000000000000000

如果需要将0.5从内存中取出来，我们就需要将01111110转换成十进制的形式就为126，然后减去127，这样就可以得到指数E;而对于M，我们就需要将第一位上的1补上，变成1.00000000000000000000000，这样我们就可以将01111110 00000000000000000000000转换成0.5。

2、E全为0

此时，浮点数的指数E等于1-127（或者1-1023）即为真实值，有效数字M不再加上第一位的1，而是还原成0.xxxxxxxx的小数。

3、E全为1

这时，如果有效数字M全为0，表⽰±⽆穷⼤（正负取决于符号位s）。

好了，关于浮点数的表⽰规则，就说到这⾥。

3.3 题目解析

下面，让我们回到一开始的代码题：

#include<stdio.h>
int main()
{
	int n = 9;
	float* pFloat = (float*)&n;
	printf("n的值为:%d\n", n);
	printf("*pFloat的值为:%f\n", *pFloat);

	*pFloat = 9.0;
	printf("n的值为:%d\n", n);
	printf("*pFloat的值为:%f\n", *pFloat);
	return 0;
}

为什么第一个*pFloat的值为：0.000000呢？

我们先来看看 int n=9;前面我们学习了整数在内存中的存储是以二进制的形式（补码）进行存储的，那也就是00000000000000000000000000001001（9的补码），float* pFloat = (float*)&n;

我们将9本来是int类型的地址转换成float类型的地址，pFloat就会认为我现在在内存中存储的就是以浮点数的存储方式进行存储的，那也就是0 00000000 00000000000000000001001（S=0,E=00000000,M=00000000000000000001001）

由于指数E全为0，所以符合E为全0的情况。因此，浮点数V就写成：

V= (-1)^0×0.00000000000000000001001×2^-126。 显然，V是⼀个很⼩的接近于0的正数，所以⽤十进制形式表示V就是0.000000。

接下来，我们再来看看第二个n 为什么等于1091567616？

浮点数9.0在内存中的存储为0 10000010 00100000000000000000000，%d是以十进制的形式打印有符号的整数（他认为内存中存储的是有符号数的补码），改*pFloat的值也就是改n中存的值，n是一个整数类型，它会将这个存储方式看成整数在内存中的存储（补码），最高位为0是一个正数，补码就是原码，我们将这个转换成十进制的形式就是1091567616。

提醒：如果想误差小一点的就用double,不然的话就用float

如有错误，请指点！！！