你真的了解数据在内存中的存储了吗？-优快云博客

本文链接：https://blog.youkuaiyun.com/2301_80153885/article/details/134661370

hello，hello，各位小伙伴，本篇文章跟大家一起学习数据在内存中的存储，并跟大家一边做题一边进行学习和理解。感谢大家对我上一篇的支持，如有什么问题，还请多多指教！

如果本篇文章对你有帮助，还请各位点点赞！！！

话不多说，正题开始

1.整形在内存中的存储

在讲解操作符详解文章中，我们学习到整数的2进制表示方法有三种：原码、反码、补码，和它们之间的转换，三种表示方法均有符号位和数值位两部分，符号位都是⽤用0表示“正”，用1表示“负”，而数值位最高位的⼀位是被当做符号位，剩余的都是数值位。

对于整形，数据存放在内存中是以补码的形式存储的，这是有原因的：

在计算机系统中，数值⼀律用补码来表示和存储。

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

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

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

 return 0;
}

我们通过调试该代码来看看整型的存储

可以看到，内存存放a的值的时候是倒着放的，是不是有点奇怪，why？

这就关乎到大小端的问题了

2.1 什么是大小端？

其实超过⼀个字节的数据在内存中存储的时候，就有存储顺序的问题，按照不同的存储顺序，我们分为⼤端字节序存储和小端字节序存储，下⾯是具体的概念：

⼤端（存储）模式：是指数据的低位字节内容保存在内存的⾼地址处，⽽数据的⾼位字节内容，保存在内存的低地址处。

小端（存储）模式：是指数据的低位字节内容保存在内存的低地址处，⽽数据的⾼位字节内容，保存在内存的⾼地址处。

小伙伴们要记住喔！！以便区分大小端

2.2 为什么有大小端?

在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一字节占8个bit，但是除了char类型占8bit，还有其他类型：short（16bit）、long（32bit要看具体的编译器）....

那这些数据该怎么存储呢？另外，对于位数⼤于8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于⼀个字节，那么必然存在着⼀个如何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。

例如：⼀个 16bit 的 short 型 x ，在内存中的地址为 0x0010 ， x 的值为 0x1122 ，那么 0x11 为⾼字节， 0x22 为低字节。对于⼤端模式，就将 0x11 放在低地址中，即 0x0010 中， 0x22 放在⾼地址中，即 0x0011 中。小端模式，刚好相反。我们常⽤的 X86 结构是⼩端模式，⽽ KEIL C51 则为⼤端模式。很多的ARM，DSP都为⼩端模式。有些ARM处理器还可以由硬件来选择是⼤端模式还是小端模式。

明白以上所说之后，我们来点练习吧

练习

1.

根据大小端的概念，设计程序用来判断当前机器是大端还是小端

其实掌握了大小端的概念这道题并不难，干说难懂，上代码：

#include <stdio.h>

int test(int a)
{
	char *p = (char*)&a;//将a的地址（4字节）强制转换为char*（1字节）类型，获得a的低地址的值
	*p = 0;//将a的低地址的值赋值为0
	if (*p == 1)//如果a的值还是1，则为大端
		return 1;
	else//反之为小端
		return 0;
}

int main()
{
	int a = 1;//16进制形式：0x00000001
	//地址从左往右，由高到低
	//大端：01 00 00 00
	//小端：00 00 00 01
	int ret = test(a);
	if (ret)
		printf("大端\n");
	else
		printf("小端\n");

	return 0;
}

我只需要抓住a地址（4字节）的低地址（1字节），对该地址的值进行操作，就可以判断大小端

2.

#include <stdio.h>
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;
}

小伙伴们猜猜打印出来的结果是什么？

相信大多萌新小伙伴们都会觉得一头雾水，打印出来结果不都是 -1 吗？

并不是喔，看答案：

这就奇了怪了，这c = 255怎么来的？别急，我们一步一步来

char类型在内存中占1字节（8bit），但是 -1 属于整型类型，占4字节（32bit），这存不下的吧，这时候就会发生截断，截断成8bit大小的二进制存放于a当中，但是我们以%d 的形式将a打印出来，所以我们要对a进行整型提升，先来讲讲整型提升的规则吧：

1. 有符号整数提升是按照变量的数据类型的符号位来提升的

2. 无符号整数提升，高位补0

//负数的整形提升
char c1 = -1;
变量c1的⼆进制位(补码)中只有8个⽐特位：
1111111
因为 char 为有符号的 char
所以整形提升的时候，⾼位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111

//正数的整形提升
char c2 = 1;
变量c2的⼆进制位(补码)中只有8个⽐特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，⾼位补充符号位，即为0
提升之后的结果是：
00000000000000000000000000000001
//⽆符号整形提升，⾼位补0

那么对a进行整型提升之后，再转化为原码进行打印

那么signed char也是一样的，因为一般来讲char就是默认有符号char类型

那么unsigned char就不一样了，这是无符号char类型，在整型提升中补的是0，而不是1

要注意：正数的原码、反码、补码都一样

3.

//代码1
#include <stdio.h>
int main()
{
 char a = -128;
 printf("%u\n",a);
 return 0;
}

//代码2
#include <stdio.h>
int main()
{
 char a = 128;
 printf("%u\n",a);
 return 0;
}

这两段代码打印出来的结果有什么不一样呢？结果分别又是什么呢？

这两打印出来的结果都一样，是一个很大的数字，怎么来的呢？首先我们要知道%u是用来打印无符号数的，也就是说在32位bit中是没有符号位一说的，那么，看图：

4.

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

这道题就有点坑了，但对于刚学习完以上内容的小伙伴来讲轻轻松松

没错，结果为255

我们要知道strlen的基本原理，是要去找'\0'也就是0，那么什么时候a字符串厘米那会出现0呢？

根据上面所学，我们得出(singed) char的范围：-128~127，(unsigned) char范围：0~255

回到题目，从-1开始减 i ，那么必然通过闭环会回到0，刚好就是绕了一圈

也就是127+128-1 = 255（0是不计数的喔），很好，你又拿下一题！！

5.

//代码1
#include <stdio.h>
unsigned char i = 0;
int main()
{
 for(i = 0;i<=255;i++)
 {
 printf("hello world\n");
 }
 return 0;
}

//代码1
#include <stdio.h>
int main()
{
 unsigned int i;
 for(i = 9; i >= 0; i--)
 {
 printf("%u\n",i);
 }
 return 0;
}

想必这两道题目已经拦不住小伙伴们，没错，这两个代码都进入了死循环

两代码陷入死循环的原因：因为unsigned char的范围：0~255，所以for循环判断条件恒成立

6.

#include <stdio.h>
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;
}

这道题目也许会有点难度，注意：该代码是在X86环境下实现的和小端系统

%x打印的是16进制的数字

ptr1相比对于上篇深入理解指针2中已经能够熟悉掌握和理解，在这里再简单讲解一下：

&a把整个a数组的地址取出来（也就是数组a的首元素地址），+1操作就是：以整个地址为单位进行+1操作，结合起来：从a[1]地址跳到a[4]地址的后一个地址

那么ptr[-1]就很好理解了，就是a[4],打印出来结果就是4

 int *ptr2 = (int *)((int)a + 1);

//我们知道除了跟在在&或者sizeof后面的数组名以外
//其他的数组名都表示数组首元素地址
//那么将a[0]的地址强制类型转换为整型，再进行+1操作
//最后再强制转换为int*类型
//那么，再进行操作之前，a[0]的地址相比于操作之后不就是+1了而已吗
//也就是ptr2从a[0]跳过了一个字节

和分析时的结果一样

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

常⻅的浮点数：3.14159、1E10等，浮点数家族包括： float、double、long double 类型。浮点数表⽰的范围： float.h 中定义

浮点型与整型的存储有有什么不一样呢？干说难懂，上代码：

#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("num的值为：%d\n",n);
 printf("*pFloat的值为：%f\n",*pFloat);
 return 0;
}

确实，浮点型在内存中的存储与整型在内存中的存储不一样，先来看结果

很奇怪是吧，但是无需担心，等我讲解完浮点型在内存存储规则你也能轻松掌握

上⾯的代码中， num 和 *pFloat 在内存中明明是同⼀个数，为什么浮点数和整数的解读结果会差别这么⼤？要理解这个结果，⼀定要搞懂浮点数在计算机内部的表⽰⽅法。根据国际标准IEEE（电⽓和电⼦⼯程协会） 754，任意⼀个⼆进制浮点数V可以表⽰成下⾯的形式：

大家都会10进制的科学计算法吧，这其实就是2进制的科学计算法

举个例子：

⼗进制的5.0，写成⼆进制是 101.0 ，相当于 1.01×2^2 。那么，按照上⾯V的格式，可以得出S=0，M=1.01，E=2。⼗进制的-5.0，写成⼆进制是 -101.0 ，相当于 -1.01×2^2 。那么，S=1，M=1.01，E=2。

那么在存储的时候也是有规定的：

IEEE 754规定：

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

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

3.1 浮点数存的过程

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

前⾯说过， 1≤M<2 ，也就是说，M可以写成 1.xxxxxx 的形式，其中 xxxxxx 表⽰⼩数部分。 IEEE 754 规定，在计算机内部保存M时，默认这个数的第⼀位总是1，因此可以被舍去，只保存后⾯的 xxxxxx部分。⽐如保存1.01的时候，只保存01，等到读取的时候，再把第⼀位的1加上去。这样做的⽬的，是节省1位有效数字。以32位浮点数为例，留给M只有23位，将第⼀位的1舍去以后，等于可以保存24位有效数字。

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

首先，E为⼀个无符号整数（unsigned int）

这意味着，如果E为8位，它的取值范围为0~255；如果E为11位，它的取值范围为0~2047。但是，我们知道，科学计数法中的E是可以出现负数的，所以IEEE 754规定，存⼊内存时E的真实值必须再加上⼀个中间数，对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。⽐如，2^10的E是 10，所以保存成32位浮点数时，必须保存成10+127=137，即10001001。

为什么加的是中间值，这个我们暂时不需要理会，只需要知道存储规则就行了

3.2 浮点数取的过程

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

1.E不全为0或不全为1：

这时，浮点数就采用下面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将有效数字M前加上第⼀位的1。

比如：0.5 的⼆进制形式为0.1，由于规定正数部分必须为1，即将小数点右移1位，则为1.0*2^(-1)，其阶码为-1+127(中间值)=126，表⽰为01111110，而尾数1.0去掉整数部分为0，补⻬0到23位 00000000000000000000000，则其⼆进制表⽰形式为:

0 01111110 00000000000000000000000

2. E全为0 ：

这时，浮点数的指数E等于1-127（或者1-1023）即为真实值，有效数字M不再加上第⼀位的1，而是还原为0.xxxxxx的⼩数。这样做是为了表示±0，以及接近于0的很小的数字。

0 00000000 00100000000000000000000

3. E全为1

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

0 11111111 00010000000000000000000

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("num的值为：%d\n",n);
 printf("*pFloat的值为：%f\n",*pFloat);
 return 0;
}

我们先把9的二进制写出来：