文章目录

前言
1.数据类型的介绍
- 1.1数据的基本归类
2.整型在内存中的存储
3.浮点型在内存中存储
- 3.1浮点数存储规则
- - 从内存中取出E的三种情况
总结

✨✨✨学习的道路很枯燥，希望我们能并肩走下来！

编程真是一件很奇妙的东西。你只是浅尝辄止，那么只会觉得枯燥乏味，像对待任务似的应付它。但你如果深入探索，就会发现其中的奇妙，了解许多所不知道的原理。知识的力量让你沉醉，甘愿深陷其中并发现宝藏。

前言

为了进一步加深数据在内存的存储理解，本篇对理解整型，浮点型在内存中的存储，进一步理解什么是大小端字节序进行了总结，希望对小伙伴们有帮助，如有错误，请在评论区指正，让我们一起交流，共同进步！

本文开始

1.数据类型的介绍

类型的意义：

使用类型开辟空间的大小.(开辟大小决定使用范围)
看待内存空间的视角.

1.1数据的基本归类

整型：(对于short,long类型int可省略不写)
char
unsigned char
signed char
short
unsigned short [int]
signed short [int]
int
unsigned int
signed int
long
unsigned long [int]
signed long [int]

signed – 有符号，unsigned – 无符号
对于我们一般写出的char,short,int long 认为是有符号整型.
例如：short == signed short

浮点型
float , double
构造类型
数组类型
结构体类型 – struct
枚举类型 – enum
联合类型 – union
指针类型
int* pi;
char* pc;
float* pf;
void* pv;
空类型：void表示空类型（无类型）
一般用于函数的返回类型、函数的参数、指针类型.

可以把void看作收纳箱，可以存储任何类型的数据，当使用void存储的类型是只需要强制类型转换就可以使用了.
示例：

int main()
{
	int a = 10;
	char ch = 0;
	void* b = &a;
	//如果要使用&a,就需要强制转换
	(int*)&a;
	void* c = &ch;
	(char*)&ch;
	return 0;
}

2.整型在内存中的存储

我们知道使用变量需要创出空间，空间大小取决于不同类型，它是如何存储在内存空间里的呢？我们来了解一下.

2.1原码、反码、补码的认识

计算机中存储整数的二进制有三种方式：原码、反码、补码.（对于整数使用）
最高位为符号位，其它为为数值位，符号位用0表示正，用1表示负.

正数：原反补码都相同.(直接由数值翻译为二进制得到)
负数：①原码：直接由数值翻译为二进制得到
②反码：原码符号位不变，其它位按位取反得到反码
③补码：反码+1得到补码

补码到原码有两种方式：
1.补码-1、取反得到原码
2.补码取反、+1得到原码
正数负数示例：

int main()
{
	int a = 20;
	//对于正数的二进制位
	// 0000000000000000000000000010100
	// 0000000000000000000000000010100
	// 0000000000000000000000000010100
	// 
	int b = -10;
	//对于负数的二进制 位
	// 1000000000000000000000000001010 - 原码
	// 1111111111111111111111111110101 - 反码
	// 1111111111111111111111111110110 - 补码
	//ox - 十六进制，1个十六进制位==4个二进制位
	// ff ff ff f6 -- 十六进制表示
	return 0;
}

对于整型来说：数据存放内存中存放的是补码.
有人可能会问 “ 原码就可以存储整数，为什么还要用补码？”

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

所以在计算 1-1 时计算机认为是在计算1+(-1),并通过补码进行运算，我们通过代码更好的理解一下.
原码补码

int c = 1 - 1;
	//补码计算
	//00000000000000000000000000000001 - 1的补码(原反补一样)
	//11111111111111111111111111111111 - -1的补码(原反补求来的)
	//00000000000000000000000000000000 - 1+(-1)=0
	//-1
	//10000000000000000000000000000001
	//11111111111111111111111111111110
	//11111111111111111111111111111111 -1补码
	//看一下原码计算
	//00000000000000000000000000000001 - 1
	//10000000000000000000000000000001 - -1
	//10000000000000000000000000000100 -> -2

通过上述代码我们知道通过原码计算1-1我们得到了-2，通过补码我们得到了0，这也证实了计算机为什么使用补码存储.

但是我们又发现了内存中的存储-10，是 f6 ff ff ff (以十六进制显示)不应该是 ff ff ff f6这样存储？怎么和我们认为的不一样呢？这就涉及了大小端让我们来看一下吧！

2.2大小端介绍

什么是大小端?

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

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

–简单来说就是1个数值超过了1个字节，要存储到内存中，就有顺序问题了.
假设存储 ox11223344,左边为低地址，右边为高地址
像十进制的123，1为百位，2为十位，3为个位
同理11就为高位字节内容，44就为低位字节内容

如果你还不明白什么大小端，我们上例子让你理解一下！

2.3大小端练习

1.简述大端字节序和小端字节序的概念，设计小程序判断当前机器的字节序.

简述：
小端字节序存储：把一个数值的低位字节内容，放到低地址，高位字节内容，存放到高地址处.
大端字节存储：把一个数值的低位字节内容，放到高地址，高位字节内容，存放到低地址处.

思路：定义一个变量，存储就两种可能大端或小端，假设变量为1，此时我们只需要取第一个字节的内容就可以判断大端还是小端.(如果是1 – 小端，如果是0 – 大端).
代码示例：

 int a=1;
 //存入就两种可能大端或小端
 //小端：01 00 00 00
 //大端：00 00 00 01
 char* p=(char*)&a;
 //&a的类型为int*需要强制转换，不同类型访问字节数不同
 if (*p == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}

2.判断下列输出内容?

//代码1
#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);
	//char a
	//11111111111111111111111111111111 - -1
	//11111111 - 存储到a的内容(发生截断)
	//打印%d是因为a是整形会发生整形提升，对于有符号位是前面补符号位，
	//11111111111111111111111111111111 - 打印整形提升完的补码  
	//10000000000000000000000000000001  a==-1；
	//signed char b=-1；与a同理
	//11111111111111111111111111111111 -1
	//11111111 - c
	//c是无符号整形，直接前面补0再打印
	//00000000000000000000000011111111 c==255
	return 0;
}

[注] ：
%u 是打印无符号整形，认为内存中存放的补码对应的是一个无符号数
%d 是打印有符号整形，认为内存中存放的补码对应的是一个有符号数

//代码2：
#include <stdio.h>
int main()
{
	char a = -128;
	//10000000000000000000000010000000
	//11111111111111111111111101111111
	//11111111111111111111111110000000 -128补码
	//10000000 - a(存储在a中的内容)
	//11111111111111111111111110000000 -整型提升完的a
	//打印的会是一个很大的数
	printf("%u\n",a);
	char b = 128;
	//000000000000000000000000100000000
	//10000000 - b
	//1111111111111111111111111100000000
	printf("%u\n",b);
	return 0;
}

上述代码可知打印char a=-128与打印char b=128；它们最后的值都一样，这就是涉及我们对数据存储的理解，所以再做这些问题时一定要画储存的二进制图，分析一下，更好的帮助我们分析！

char类型存储图示：

//代码3
int main()
{
	char a[1000];
	int i;
	for(i=0; i<1000; i++)
	{
		a[i] = -1-i;
	}
	//strlen求字符串长度需要找到\0为结束标志
	//\0的ASCII值为0,所以就是求0前面存的值
	//char类型图如上存储范围为-127~128
	//0之前存储128+127=255
	printf("%d",strlen(a));
	return 0;
}

3.浮点型在内存中存储

我们常见的浮点数：

3.1415926
1E10

那么浮点数是如何存储的呢？
我们来看一段代码：

int main()
{
	int n = 9;
	float *pFloat = (float *)&n;
	printf("n的值为：%d\n",n);//1：9
	printf("*pFloat的值为：%f\n",*pFloat);//2：0.000000
	*pFloat = 9.0;
	printf("num的值为：%d\n",n);//3：1091567616
	printf("*pFloat的值为：%f\n",*pFloat);//4：9.000000
	return 0;
}

上述代码你的结果是什么呢？
从结果来看，浮点型的存储应该和整型的不一样，那它有是如何存储呢？

3.1浮点数存储规则

关于浮点数存储，我们先来了解一下国际的规则！
根据国际标准IEEE（电气和电子工程协会） 754 ,任意一个二进制浮点数V可以表示成下面的形式：

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

其实存储浮点数，就需要找到S,M,E
我们看一下它们在内存中的存储：
IEEE 745规定：

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

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

IEEE 764对有效数字M和指数E有特别规定
对于M：
IEEE 754规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的小数部分。比如保存1.01的时候，只保存01，等到读取的时候，再把第一位的1加上去。
目的是：节省1位有效数字。以32位浮点数为例，留给M只有23位，将第一位的1舍去以后，等于可以保存24位有效数字。

对于E：
E为无符号整数，如果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.

从内存中取出E的三种情况

E全为0或不全为1

指数E的计算值减去127（或1023），得到真实值，再将有效数字M前加上第一位的1.
例如：0.5的二进制形式是0.1，由于规定正数部分必须是1，所以小数点向右移动1位，为1.0*2^(-1),E：-127+1=126，表示01111110，M:去掉整数1的部分为0，补齐23位0000000000000000000000.
表示：0 01111110 00000000000000000000000

E全为0：内存中直接取出126或者1022

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

E全为1：

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

我们来看例子实现一下吧！
例如浮点数：5.5

下面代码我们通过观察内存来看浮点数在内存中的存储情况：

#include<stdio.h>
int main()
{
	float a = 5.5f;
	//101.1 - M必须保证在1到2范围内
	//1.01*2^2
	//(-1)^0*1.011*2^2
	//S:0
	//M:1.011   存储省略1
	//E:2   存储时需要+127
	//0 10000001 011000000000000000000000
	//S   E     M
	//换成十六进制
	//0100 0000 1011
	//40 b0 00 00

	return 0;
}

因为编译器为小端存储，所以我们需要倒着看，10 b0 00 00;与我们换算的一样，这就是浮点数的存储方法.

关于我们刚开始的代码我们来分析一下结果.

	int n = 9;
	float *pFloat = (float *)&n;
	printf("*pFloat的值为：%f\n",*pFloat);//2：0.000000
	//2的结果是怎么来的呢？
	//9本来是整数，但是以浮点数的形式来拿出来
	//00000000 00000000 00000000 00001001 - 整型
	//0 00000000 00000000000000000001001 - 浮点数的角度
	//正好E为全是0的情况，E=-126,正数S=0,
	//M=0.000000000000000000001001
	//V=(-1)^0×0.00000000000000000001001×2^(-126)=1.001×2^(-146)
	//所以V为接近0的小数，打印小数取六位小数就是0.000000

	*pFloat = 9.0;
	printf("num的值为：%d\n",n);//3：1091567616
	//9.0是浮点数存储在整数n中
	//1001.0->1.001*2^3
	//S=0,E=3,M=001
	//0 10000010 00100000000000000000000 - 浮点型存储
	//01000001000100000000000000000000 - %d角度
	//符号位为0是整数，%d角度来看会打印出一个较大的数
	//打印结果：1091567616

总结

✨✨✨各位读友，本篇分享到内容是否更好的让你理解了数据在内存中存储，遇到代码BUG也帮助我们有了新的思路，如果对你有帮助给个👍赞鼓励一下吧！！
🎉🎉🎉世上没有绝望的处境，只有对处境绝望的人。让我们一起努力，一起看更好的风景吧！
感谢每一位一起走到这的伙伴，我们可以一起交流进步！！！一起加油吧！！！

本文含有隐藏内容，请开通VIP 后查看

数据在内存中的存储 -- (理解大小端，整型，浮点型的存储)