带你认识数据是如何在内存中存储的---C语言

平凡少年丶

已于 2022-05-26 13:39:46 修改

阅读量528

点赞数 8

文章标签： c语言开发语言

于 2022-05-25 18:11:48 首次发布

本文链接：https://blog.csdn.net/qq_40005416/article/details/124959298

版权

文章目录

前言
一、数据类型介绍
- 1.1.类型的基本分类
二、整形在内存中的存储
三、浮点数存储规则
总结

前言

同学们，大家好。不知道你们有没有好奇过，当你在代码中创建一个变量的时候，变量的数据是如何在内存中进行存储的呢？
今天，我来带领大家一起认识下在C语言中数据是如何在内存中进行存储的。

一、数据类型介绍

要了解数据在内存中的存储，首先我们要认识数据类型

在C语言中，我们常用的int char float…等等，其实都是C语言的内置类型
C语言的内置类型有：

char  		//字符数据类型		大小：1字节
short 	 	//短整型数据类型		大小：2字节
int  		//整形数据类型		大小：4字节	
long  		//长整型数据类型		大小：4/8字节		注：在C语言标准中，未对long类型的大小做一个明确的定义，只是说明long类型的大小>=int类型的大小
long long  	//更长的整形数据类型	大小：8字节
float  		//单精度浮点型数据类型	大小：4字节
double  	//双精度浮点型数据类型	大小：8字节

那么C语言的内置类型有什么意义呢？

使用该类型能在内存开辟多大的空间
类型决定了你如何访问内存空间

例如：一个char c的变量，因为char类型的大小为1个字节，所以当你创捷了一个char类型的变量c的时候，会在内存中开辟1个字节大小的空间。并且因为该变量类型是char类型，所以当你使用该变量时，只能在内存中访问一个字节大小的空间

#include<stdio.h>
int main()
{
	int a = 0x11223344;	//0x11223344是以十六进制显示的整数，放在整形变量中
	char* c = &a;
	printf("a=%x\n", a);
	printf("%x\n", *c);	//%x以十六进制形式打印指针变量c指向的数据
	return 0;
}

在这里插入图片描述
一位十六进制数占4个bit位，两位十六进制数占8个bit位，也就是一个字节。变量a是整形，能存放四个字节的数据，使用变量a时也就能访问四个字节大小的空间。变量c是字符指针类型，存放的是a的地址，使用变量c时也就能访问一个字节大小的空间。

1.1.类型的基本分类

C语言的内置类型分为两种

整形家族

 char
 	unsigned char
 	signed char
 short
 	unsigned short
 	signed short
 int
 	unsigned int
 	signed int
 long
 	unsigned long
 	signed long

注：unsigned表示无符号数，signed表示有符号数。默认创建的整形家族变量都是signed类型的。

浮点数家族
```
 float
 double
```

C语言中，除了内置类型，还有一些其他类型
例如

构造类型

 数组类型	//我们常用的数组其实属于构造类型 int arr1[5]的类型为int [5]，int arr2[8]的类型为int [8],char arr3[5]的类型为char [5].这三个数组属于不同类型
 结构体类型 struct
 枚举类型 enum
 联合类型 union

指针类型

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

空类型

 void 表示空类型（无类型）
 通常用于函数的返回类型，函数的参数部分，指针类型

今天，我们来详细认识下整形在内存中是如何存储的。

二、整形在内存中的存储

介绍整形在内存中的存储之前，我们先来认识下有符号数和无符号数。

2.1.有符号数和无符号数

什么是有符号数呢？
有符号数就是数据有正负之分。在数学中，我们会有负数，也有正数。
无符号数就是数据没有正负之分。在生活中，我们有很多数据是没有负数的。比如：身高，体重，年龄…等等。

而在代码中，我们将数据分为有符号数和无符号数。
我们知道，一个变量的创建会在内存中开辟一块空间，空间的大小由变量的类型来决定。而整数在内存中存储的时候，我们有符号位和数值位之分。在有符号数中，整数类型的最高位表示符号位，其余位表示数值位。无符号数则没有符号位和数值位之分。所有位都表示数值位

我们创建一个变量
int a=10;	//a是一个有符号的整形变量，整形的大小为4个字节==32bit位，写出a的二进制序列
0 0000000000000000000000000001010	//最高位表示符号位，符号位为0表示正数，为1表示负数
当我们需要一个无符号的数时，我们可以这样写
unsigned int b=20;	//这时b就是一个无符号的整形变量。

2.2.原码、反码、补码

那么，当我们创建一个变量的时候，这个变量的数据到底是怎么在内存中存储的呢？

比如
int a=10;
int b=-20;

我们还需要认识一个东西，原码、反码、补码。计算机中的整数有三种表示形式，三种表示方法均有符号位和数值位两部分，符号位都是用0表示“正”，用1表示“负”
负数的三种表示方式各不相同

原码
直接将数据按照正负的形式翻译成二进制就是原码
反码
原码的符号位不变，其余位按位取反
补码
反码+1就是补码

正数的原、反、补码都相同。

对于整形来说，数据在内存中存储的是补码
为什么呢？

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

例如：当我们要计算1-1时，由于cpu只有加法处理器，所以我们需要将1-1转换为1+(-1)
1+(-1)
1的原码
00000000000000000000000000000001
-1的原码
10000000000000000000000000000001
直接使用原码相加
00000000000000000000000000000001	//1
10000000000000000000000000000001	//-1
10000000000000000000000000000010	//-2
我们会发现计算的结果是-2，这个结果明显不正确。所以用原码来进行计算是不对的。
下面我们来用补码进行计算
1的补码，1是正数，原、反、补码相同
00000000000000000000000000000001 //1的原码
00000000000000000000000000000001 //1的反码
00000000000000000000000000000001 //1的补码
-1的补码
10000000000000000000000000000001 //-1的原码
11111111111111111111111111111110 //-1的反码
11111111111111111111111111111111 //-1的补码
使用补码相加
00000000000000000000000000000001
11111111111111111111111111111111
100000000000000000000000000000000	//由于整数的大小只有4个字节，所以我们需要截断，只留下后32个bit位
最终结果
00000000000000000000000000000000	//0
使用补码进行计算，结果是正确的。
在这里说明一下，为什么用补码就是正确的，以及补码是如何出现的，我们不进行讨论，只要知道这个结论就可以，感兴趣的同学可以自行去搜索

最后还有一个知识
原码–>补码可以取反+1，而补码–>原码也可以按照取反+1得到
这个也是原、反、补码的一个特性，至于为什么我也不清楚。

了解了以上内容，那么大家就对整数在内存中的存储有一个整体的认识了。
而关于有符号数和无符号数还有一个问题不知道大家有没有注意到：有符号数和无符号数所表示的范围有所差异

下面我们以char类型为例，来介绍有符号数和无符号数所表示的范围。
char类型大小为一个字节，8个bit位，我们用char类型来创建一个变量。
char a=0； //我们知道，内存中存储的是二进制。所以我们写出变量a的二进制是这样的。
00000000	char a默认是有符号数，所以最高位表示符号位。最高位为0表示正数，为1表示负数。我们可以写出8位二进制的所有表示形式
00000001	//十进制中的1	
00000010	//十进制中的2
00000011	//十进制中的3
......
01111110	//126
01111111	//127
-------------//我们知道整形在内存中存储的是补码，而我们使用的是原码。正数原、反、补码相同，所以正数部分没什么说的，负数则不一样
10000000	//而这个当我们进行计算时，会发现计算的结果为100000000，超出了char类型所占大小的范围。所以实际上不会对这个数据进行计算，而是直接解析为-128
10000001	//-127
10000010	//原码为11111110 这是-126
......
11111101	//-3
11111110	//这就是-2
11111111	//这是补码，原码为10000001 也就是-1
一个有符号的char的取值范围就为：-128--127
那么无符号的char的取值范围是多少呢？其实也就是：0--255
同理，其他整形家族的类型的取值范围也是一样的计算。

2.3.大小端介绍

当我们知道了整数在内存中是以补码的方式进行存储的时候，那么还有最后一个问题。补码在内存中是如何存储的呢？
在内存中，数据的存储是以字节为单位的，当数据大小超过一个字节时，就会有存储顺序的问题。
这里就有了我们的大小端字节序存储模式。

大端（存储）模式，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址中。
小端（存储）模式，是指数据的低位保存在内存的低地址中，而数据的高位,，保存在内存的高地址中。

为什么有大端和小端：

为什么会有大小端模式之分呢？
这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为8 bit。但是在C语言中除了8 bit的char之外，还有16 bit的short型，32 bit的long型（要看具体的编译器），另外，对于位数大于8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。
例如：一个 16bit 的 short 型 x ，在内存中的地址为 0x0010 ， x 的值为 0x1122 ，那么 0x11 为高字节， 0x22 为低字节。
对于大端模式，就将 0x11 放在低地址中，即 0x0010 中， 0x22 放在高地址中，即 0x0011 中。小端模式，刚好相反。
我们常用的 X86 结构是小端模式，而 KEIL C51 则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。

三、浮点数存储规则

我们来看一段代码

#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;
}

这段代码输出的结果是什么呢？
在这里插入图片描述
我们可以看到是这样的值，是不是和我们预想中的有所区别，这是为什么呢？
因为浮点数和整数在内存中存储的方式不同
下面我们先来看看浮点数是如何在转换为二进制的
根据国际标准IEEE（电气和电子工程协会） 754，任意一个二进制浮点数V可以表示成下面的形式：

(-1)^S * M * 2^E
(-1)^s表示符号位，当s=0，V为正数；当s=1，V为负数。
M表示有效数字，大于等于1，小于2。
2^E表示指数位。

举例说明

例如
十进制的5.0，写成二进制为101.0
5.0 可以分为两部分，小数点前和小数点后，小数点前权值从10^0开始递增，小数点后权值从10^(-1)开始递减。
类比到二进制中也是如此，所以二进制中小数点后面是从2^(-1)开始。
101.0按照标准来说可以写成这样1.01*2^2       PS：这里可以类比十进制101写成小数就是1.01*10^2
因为101.0是正数，所以S=0，M=1.01，E=2

再来写一个，十进制的5.5
写成二进制就是101.1，小数点后的1就是1*2^(-1) 也就是0.5
101.1 按照标准写成 1.011*2^2
所以S=0，M=1.011，E=2

接下来说内存中是怎么存储的
IEEE 754规定：对于32位的浮点数(float类型)，最高的1位是符号位s，接着的8位是指数E，剩下的23位为有效数字M。
在这里插入图片描述
对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M。

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

举例

int main()
{
	float a = 5.5;
	//写出a的二进制序列
	//101.1
	//按照标准写成
	//1.011*2^2
	//(-1)^0*1.011*2^2
	//S=0,M=1.011,E=2
	//E的真实值为2，存储值为2+127=129，129写成二进制为10000001
	//M的值为1.011，存储的是小数点后的部分 011 ，因为任何一个小数写成二进制形式，M一定2>M>=1，M不够所需位数时，后面自动补0
	//最终存储的是
	//0 10000001 01100000000000000000000
	//写成十六进制为
	//0100 0000 1011 0000 0000000000000000
	//40 b0 00 00
	return 0;
}

在这里插入图片描述
我们可以看到内存中存储的就是这样的值

了解了怎么存，接下来我们来学习如何取?
取得时候，M部分和S部分没什么说的，直接取出来就是，M部分取出来后，自动加上第一位的1就可以。
然后，指数E从内存中取出还可以再分成三种情况：
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

E全为0

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

当E为全0时，E的真实值就直接为-126/-1022，也就是0.xxxx*2^(-126)，这是一个无限小的数字

E全为1

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

当E为全1时，E的真实值就直接为255/2,047，也就是2^255，这是一个无限大的数字

以上就是浮点数在内存中存储的一些简单规则。
下面我们再来看看那道练习题

#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写成二进制
00000000000000000000000000001001	//以%d的形式打印n就是9
pFloat是一个float类型的指针，它认为内存中存储的浮点数，所以会以浮点数的形式取出内存中的数据
0 00000000 00000000000000000001001	//我们可以看到E部分为全0，所以E=-126，M=0.00000000000000000001001，S=0
(-1)^0*0.00000000000000000001001*2(-126)，这是一个无限小的数字，所以会打印出来0.000000
接下来*pFloat=9.0; pFloat是一个float类型的指针,会以浮点数的形式存储在内存中
9.0的二进制序列为1001.0
9.0--> 1001.0 -->(-1)^01.0012^3 --> s=0, M=1.001,E=3+127=130，130的二进制序列10000010
最终的二进制序列为
0 10000010 00100000000000000000000	//以浮点数的形式打印出来也就是9.0
0 10000010 00100000000000000000000	//以整数的形式打印出来就是1091567616