数据在内存中的存储（c语言）_c语言中内存是倒着存的么-优快云博客

本文链接：https://blog.youkuaiyun.com/2301_76815082/article/details/131630728

深度剖析数据在内存中的存储

本章重点

1. 数据类型详细介绍
2. 整形在内存中的存储：原码、反码、补码
3. 大小端字节序介绍及判断
4. 浮点型在内存中的存储解析

1. 数据类型介绍

前面我们已经学习了基本的内置类型（内置类型指c语言本身具有的）：

char     //字符数据类型（1个字节）
short    //短整型（2个字节）
int     //整形（4个字节）
long     //长整型（4/8个字节）
long long //更长的整形（8个字节）
float    //单精度浮点数（4个字节）
double    //双精度浮点数（8个字节）
//C语言有没有字符串类型？

以及他们所占存储空间的大小。

这里给大家看一下整形能表示的范围：

#include<limits.h>/这个头文件就限定了整形能表示的最大值/最小值
int main()
{
	INT_MAX;/整形能表示的最大值就叫这个
	return 0;
}

然后把光标放在INT_MAX，然后右击，选择转到定义，就可以看到如下图，它最大值，最小值的范围，还有其他类型的范围。

类型的意义：

1. 使用这个类型开辟内存空间的大小（大小决定了使用范围）。
2. 如何看待内存空间的视角。

1.1 类型的基本归类：

整形家族：

char
unsigned char
signed char
short
unsigned short [int]
signed short [int]
int
unsigned int
signed int
long
unsigned long [int]
signed long [int]

long long(把他放在整形家族是因为，字符在存储的时候，存储的是ASCII，是整形，所以归类的时候放在整形家族）

对于整型家族来说：他有有符号无符号的区分。

比如说: unsigned char(无符号的char)

signed char(有符号的char)

这里写成：

当我写成有符号的sign short == short(==等价于）

当写成无符号的时候必须写成unsigned short

上面那些同理，除过char.

char 到底是signed char 还是unsigned char 其实是不确定的

char在VS--->signed char

无符号的表示成unsigned char

说了半天，那signed和unsigned到底在哪里做区分呢？比如说如下：

signed char

char是一个字节，8个比特位，假如是：01010111，对于signed char来说，他会把最高位0当作符号位

unsigned char

对于unsigned char来说，他不会把最高位0当作符号位，他把8个位都当成数值位。

所以说char是这样，其他的也是这样，如int，short也一样，如有符号的short16个比特位中最高位是符号位，剩下的15个比特位是数值位。而无符号的short,16个比特位全部都是数值位。

那一个有符号位（signed)和一个无符号位（unsigned)范围各是什么呢？

举例来说：

一个char，只有8个比特位，这8个比特位里面，如果我们用来存放数据的话，有以下情况：

假设如上图存放的二进制位都是有符号的char，前面用红色圈起来的都是符号位，以中间的红横线为分界线，上面是正数，下面是负数。正数原码反码补码相同，所以第一个就是0，依次往下（中间那个负的128，其实是不算的，直接定义成-128）。那他的范围是-128~127.

假设上图是无符号位的char，这里没有符号位（没有符号位，就是没有负数），所有的都是（有效位）数值位。他的范围是0~255.假设这里后面给他再2加1，进上去之后就变成00000000.就回到开头了，所以说他是有轮回的。就可以把他画成如下的图：

（如上有符号的）

（如上无符号的）

如果以后我们想表示一个恒大于等于0的数字的时候，就把它定义成一个

unsigned的值。如果它有正有负，就把它定义成signed的值。

那short的范围就是如下图：

浮点数家族：

float
double

构造类型（自定义类型，也叫构造类型）：

> 数组类型
> 结构体类型 struct
> 枚举类型 enum
> 联合类型 union

数组类型(数组也是自定义类型）：
int arr1[10]; --> int [10]
int arr2[5]; --> int [5]
char arr3[5]; --> char [5]

-->这个指他的类型，如第一个它的类型是int [10]

指针类型：

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

也包括结构体类型

空类型：

void 表示空类型（无类型）
通常应用于函数的返回类型、函数的参数、指针类型。

2. 整形在内存中的存储

我们之前讲过一个变量的创建是要在内存中开辟空间的。空间的大小是根据不同的类型而决定的。

那接下来我们谈谈数据在所开辟内存中到底是如何存储的？

比如：

int a = 20;/这里就创建了一个整型变量，叫a，这时a向内存申请4个字节来存放数据，下面一样
int b = -10;

我们知道为 a 分配了四个字节的空间。
那这四个字节是如何存储？
下来了解下面的概念：

2.1 原码、反码、补码

计算机中的整数数据有三种2进制表示方法，即原码、反码和补码。
三种表示方法均有符号位（最高位叫符号位）和数值位（除过最高位剩下的都是数值位）两部分，符号位都是用0表示“正”，用1表示“负”，而数值位正正数的原、反、补码都相同。

负整数的三种表示方法各不相同。

原码
直接将数值按照正负数的形式翻译成二进制就可以得到原码。
反码
将原码的符号位不变，其他位依次按位取反就可以得到反码。
补码
反码+1就得到补码。

如下举例：
int main()
{
	int num1 = 10;//4个字节—32个比特位
	/10的二进制是1010（从右往左，0乘2的0次方，1乘2的1次方，0乘2的2次方，1乘2的3次方）因为10是正 
      整数，所以第一个（符号位）是0，再补27个0即可
	/00000000000000000000000000001010—原码
	/又因为正整数原码，反码，补码相同
	/00000000000000000000000000001010—反码
	/00000000000000000000000000001010—补码
	int num2 = -10;//也是4个字节
	/因为-10是负整数，所以第一个（符号位）是1，再补27个0即可
	/10000000000000000000000000001010-原码
	/11111111111111111111111111110101-反码
	/11111111111111111111111111110110-补码

}

这里我们就要想，为什么要写出补码呢？

因为对于整形来说：数据存放内存中其实存放的是补码。

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

我们看看在内存中的存储：

课堂图：

从图中我们可以看出他放的值01000000，这里有人就想，为什么他放的值和我们看到的不一样呢？其实本质上内存中存放的是二进制，在VS上为方便展示，显示的是16进制（这个上面是倒着放的）。

再来看另一个值：

课堂图：

（注意：4个二进制位抵一个16进制位）

这里图中符号位应该是1，这里打错啦，希望友友不要介意。

不管怎样，我们这里从图中可以看出，内存中存储的是补码，而且是倒着存储的！

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

举例（为什么要用补码）：

假设模拟计算1 - 1
  我们在前面看到（CPU只有加法器），那减法怎么做呢，其实减法使用加法来模拟的，如下：
1+(-1)  1-1用加法模拟成1+（-1），有了这样的转换就可以做减法了 
 00000000000000000000000000000001 --> 1的补码
 11111111111111111111111111111111 --> -1的补码
 00000000000000000000000000000000-->两个相加的结果
 
 原码计算是错误的
00000000000000000000000000000001
10000000000000000000000000000001
10000000000000000000000000000010---> -2



因为y是用补码进行计算的，所以在内存中存储的是补码，用补码进行计算很方便

从上上图中我们可以看到对于num1和num2分别存储的是补码。但是我们发现顺序(倒着存储）有点不对劲。
这是又为什么？

2.2 大小端介绍

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

什么是大端小端呢？

我们以0x11223344为例，它可以切成四个字节0x11 22 33 44,那这个数字在内存中到底以怎样的形式存进去的的呢？此时，又让人就有不同的想法，如下假设是我们的内存。

存储的意义不看他是怎样存储的，只要按照怎样存进去的方法再怎样拿出来就行了。所以按照这个说法，以上存储的方式都对。

但是像倒数第一二，存储的很乱，到要拿出来的时候就特别不方便，所以最终它选择了两种方便的存储，第一和（按顺序存进去的）第二（倒着存进去）两种方式。这两种方式不管存进去还是拿出来都非常简单。

把第一种方式叫大端字节序存储，第二种方式叫小端字节序存储。

#字节序——是以字节为单位，讨论存储顺序的(11 22 33 44都各带一个字节）

0x11 22 33 44中44是低位字节的内容，向前走到11，11是高位字节的内容。

小端字节存储：是指把一个数据的低位字节的内容，存放在低地址处，把一个数据的高位字节的内容,存放在高地址处。

大端字节存储：是指把一个数据的低位字节的内容，存放在高地址处，把一个数据的高位字节的内容,存放在低地址处。

注意：

char类型的数据存储的时候不需要注意顺序，因为他只有一个字节

为什么有大端和小端：

为什么会有大小端模式之分呢？这是因为在计算机系统中，我们是以字节为单位的，每个地址单元
都对应着一个字节，一个字节为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处理器还可以由硬件来选择是大端模式
还是小端模式。

写个程序，如何判断大小端呢？

假设以int a = 1;为例：

int a = 1;

写成16进制的话是:0x 00 00 00 01

假设我们大小端存放的方式如上图，假设左边是低地址，右边是高地址。

那我们a在地址里面存放的时候，以小端的方式存放是第一种情况，以大端的方式存放是第二种情况。

如果要对比的话，只需要对比第一个字节的内容，就可以区分出大端小端，因为第一个字节里面存放的是01，就是1，所以他存的小端，第二个存放的是00，就是0，所以它存的大端。

那怎么拿出第一个字节呢？

其实很简单，上面说到a有四个字节，给01&a即可拿到第一个字节，&a的类型是int*,int*的地址解引用直接可以访问四个字节。我们这里把&a的类型int*强制类型转换成char*,当把他的类型强制转换成char*之后再去解引用，它可以访问一个字节。逻辑如下：

（char*）&a:这样就变成char*的指针了

*（char*)&a:这样指访问a的第一个字节

if(*（char*)&a==1)--->指小端

else(就是大端）

如下代码实现：

如果向上面这样写，编译器就会报错。

如下这样写：

百度2015年系统工程师笔试题：

请简述大端字节序和小端字节序的概念，设计一个小程序来判断当前机器的字节序。（10分）
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 1;
	char* p =(char*) &a;
	if (*p == 1)
		printf("小端\n");
	else
		printf("大端\n");
	return 0;
}






//简化代码：
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 1;
	if (*(char*)&a == 1)
		printf("小端\n");
	else
		printf("大端\n");
	return 0;
}







//此时上面的代码有点啰嗦，再来简化一下。（这里小端返回1，大端返回0）
int check_sys()
{
	int a = 1;
		return*(char*)&a;
}
int main()
{
	int ret = check_sys();
	if (ret == 1)
		printf("小端\n");
	else
		printf("大端\n");
	return 0;
}





//写个函数判断：
int check_sys()
{
	int a = 1;
	if (*(char*)&a == 1)
		return 1;
	else
		return 0;
}
int main()
{
	int ret = check_sys();
	if (ret == 1)
		printf("小端\n");
	else
		printf("大端\n");
	return 0;
}

练习：

整形提升时，如果是有符号时，是按照变量的数据类型的符号位来提升的
如果无符号是，直接补0

/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);
	return 0;
}


结果是：a=-1,b=-1,c=255
那他的结果是怎么来的呢？接着往下看：
#include <stdio.h>
int main()
{
	char a = -1;
	/10000000000000000000000000000001
	/11111111111111111111111111111110
	/11111111111111111111111111111111-截断(这是-1的补码，要放到a里面去，（4个字节放到一个字节里面去）放不下）
	/11111111 -a（所以a是有符号的char)
	/ a要提升，要按照自己的类型来提升的，他是char a,就是有符号的char,说明高位是符号位，那在11111111的高位直接补1，如下：
	/11111111111111111111111111111111（补完1之后，这是补码，要以%d的形式打印要打印原码）
	/11111111111111111111111111111110-反码
	/10000000000000000000000000000001--> -1（取反）

	signed char b = -1;
	/11111111111111111111111111111111-截断（b和a提升时一模一样）
	/11111111 -b

	unsigned char c = -1;
	/11111111 -c
	/ c发生整形提升的时候看c的类型，unsigned char，无符号要提升的时候高位要补0，补完之后，要以%d的形式打印，看高位为0，则他是正数，原反补相同）
	/00000000000000000000000011111111
	/
	printf("a=%d,b=%d,c=%d", a, b, c);
	/他们三个都是11111111，那为什么结果不一样呢？
	/ 因为他们是char类型，而%d - 十进制的形式打印有符号整型整数（无符号的是%u）
	/所以这里要发生整型提升

	return 0;

2.下面程序输出什么？
#include <stdio.h>
int main()
{
	char a = -128;
	printf("%u\n", a);
	return 0;
}

结果是：4294967168
那他的结果是怎么来的呢？接着往下看：
#include <stdio.h>
int main()
{
	char a = -128;
	/-128
	/10000000000000000000000010000000->原码
	/11111111111111111111111101111111->反码
	/11111111111111111111111110000000->补码
	/要把-128的补码存到a里面去（截断），如下：
	/10000000（把他以%u的形式打印（整形提升））
	/11111111111111111111111110000000->补码    （a的类型是char，高位1是符号位，补1）
	/要以%u形式打印，内存存的无符号数，无符号数无符号位，无符号数可以看成正数，原反补相同，所以把a当成一个数值打印出来了）
	printf("%u\n", a);
	return 0;
}

3.这个代码的输出结果是什么？
#include <stdio.h>
int main()
{
	char a = 128;
	printf("%u\n", a);
	return 0;
}
结果是：4294967168
我们发现，这个代码结果和上面一个一模一样，为什么呢？因为他们存在内存中的值是一样的


#include <stdio.h>
int main()
{
	char a = 128;
	//00000000000000000000000010000000（正数）
	//10000000-a
	//
	printf("%u\n", a);
	return 0;
}
我们发现这里的a和上面的a里面存放的值一模一样，所以，因为他们存进去的结果是一样的，所以打印的结果也是一样的，算法也一样

4.这个代码的输出结果是什么？
#include<stdio.h>
int main()
{
	int i = -20;
	unsigned int j = 10;
	printf("%d\n", i + j);
	return 0;
}

结果是：-10



/按照补码的形式进行运算，最后格式化成为有符号整数
int main()
{
	int i = -20;
	/10000000000000000000000000010100->原码
	/11111111111111111111111111101011
	/11111111111111111111111111101100->补码
	/
	unsigned int j = 10;
	/00000000000000000000000000001010
	
    /00000000000000000000000000001010
	/11111111111111111111111111101100
	/相加
	/11111111111111111111111111110110->补码
	/11111111111111111111111111110101
	/10000000000000000000000000001010 -10（原码）
	printf("%d\n", i + j);
	return 0;
}

这里补充一点：

我们要把原码写成补码：原码取反加一得到补码。

要是把补码写成源码该怎么做呢？

第一：原路返回是一种思路，如图绿色

第二：补码取反加一，如蓝色

下面以上面一个代码为例：

int main()
{
	int i = -20;
	//10000000000000000000000000010100->原码
	//11111111111111111111111111101011
	//11111111111111111111111111101100->补码
	//
	unsigned int j = 10;
	//00000000000000000000000000001010
	
     //00000000000000000000000000001010
	//11111111111111111111111111101100
	//相加
	//11111111111111111111111111110110->补码
	//11111111111111111111111111110101
	//10000000000000000000000000001010 -10（原码）
	//第二种情况
	/11111111111111111111111111110110
	/10000000000000000000000000001001
	/10000000000000000000000000001010
	printf("%d\n", i + j);
	return 0;
}

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






因为他前面的有效结果会一闪而过，所以我们这里给他加上Sleep，让结果打印的慢一点，代码如下：

#include <windows.h>
int main()
{
	unsigned int i;
	for(i = 9; i >= 0; i--)
	{
		printf("%u\n", i);
		Sleep(1000);//单位是毫秒
	}

	return 0;
}

不加Sleep时的结果：

我们可以发现，程序进入死循环（一直往下减）。

加Sleep时的结果：

我们可以发现，他前面，打印了10个数字之后突然变成非常大的数字还在一直往下减，开始进入死循环，那为什么一直往下减呢？

从数学角度看，0再减之后就是-1，变成-1之后，这个值永远放在unsigned int里面，因为i的类型是正，所以当-1的时候，-1再放到i里面，-1被当成一个无符号数子来看待，我们知道，-1的二进制序列是32个1，这32个1被当成无符号数的时候就是我们看到的进入死循环的那些非常大的数。我们再来回想一下我们当初讲过的东西，unsigned int他是无符号数，它里面没有符号位，他表示的值是恒大于等于0的，用我们上面的char类型来看的话，（如下图），她是从一个全0变成一个非常大的正数。32个1表示的是最大的正数，随意这个代码会死循环，因为i是无符号整数，它恒大于等于0，他的最小值是0，所以他永远成立，所以死循环。

那为什么第二个代码中打印了9，8，7，6，5，4，3，2，1，0之后是非常大的正数呢？

因为，我们放在i里面的数字，i你不管是什么数字，他都会当成无符号来看的，当我们0再减一遍被当成无符号数再来看的时候，它将是一个非常大的正数。（虽然说数学上是-1，当-1被存到无符号数里面，再以%u的形式打印，它将是一个非常大的数）。

当我们这里是int的时候，观察下图：

我们发现，把unsigned int i 改成int i的时候，他打印的结果就没有死循环了。因为在int里面你在减他就是-1，而-1是不会打印的，所以它不会死循环。

6.
#include <string.h>
int main()
{
	char a[1000];/给了个字符数组，初始化
	int i;
	for (i = 0; i < 1000; i++)/循环
	{
		a[i] = -1 - i;/给这个数组里面赋值，这1000次循环完之后，这1000个元素就赋值完了
	}
	printf("%d", strlen(a));
	return 0;
}

结果是：255

分析：这个数组1000个元素，循环进来循环1000次，循环1000次，他的下标就是0~999，刚好是这个数组的下标，把这个数组一个一个覆盖，那我们覆盖什么值呢？看上面我们发现，i是0的时候，-1-0就是这个数组放进去-1，当i变成1的时候，-1-1就是放进去-2，-2放在了下标为一的元素上，依次类推，从数学角度看，这里最后放的是-1000，但是char类型范围是-128~127，他不可能存放太小的数字，像-129，-130...都是存不了的，当你非要存的时候，会根据此图变化。

所以我们在这里不能想当然的就一直存下去。此代码中减一朝箭头这个方向走。

char类型的范围是-128~127。

所以这个数组是这样放的。

以上图的方式将这1000个数字填满。

strlen是求字符串长度的，统计的是\0之前出现的字符的个数。 \0的ASCII码值是0. 这里只要找到0就行。如上图，从-1到0找0，-1到-128是128个数字，127到1是127个数字，总共加起来是255个元素，当经过255个元素之后就是0，所以当strlen求的时候是255个元素。（这里strlen要包含头文件）。

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

结果是：hello worlds死循环

为什么是死循环呢？

我们刚才分析了unsigned char i = 0的范围是0~255，这里条件显示，i<=255,这个条件恒成立，这个条件成立，就死循环。

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

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

为什么叫浮点数呢？

浮点数：数学中的小数

例如：123.45

我们就可以把它写成：12.345*10^1（12.345乘10的1次方）也可以把他写成1.2345*10^2，那他这种科学计数法的表述我们可以发现，这个小数点是可以移动（浮动）的，所以他叫浮点数，在他浮动的过程中我们我们给他乘上一个权重（指后面10^1,10^2），它的值是不变的。

所以我们这里探索这种小数在内存中是怎么存储的。

1E10 ——>1.0*10^10 E指底数10，后面10指次方的意思。

上节课我们说：

整型家族的类型，表示的限制范围在：limits.h文件里

浮点的限制范围在：float.h这样的文件里

3.1 一个例子

浮点数存储的例子：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int n = 9;    /这里创建了一个整形变量n，n，向内存申请了4个字节
	float* pFloat = (float*)&n; /把这四个字节地址取出来强制类型转换成float*，
                               把n的地址取出来赋给pfloat，pfloat是float*的指针
 
	printf("n的值为：%d\n", n);/打印n的值,以%d形式打印的
	printf("*pFloat的值为：%f\n", *pFloat);/打印*pfloat（把pfloat解引用一下，得到一个值），
                                           这个值以%f的形式打印
 
	*pFloat = 9.0;/pFloat指向int n的n，*pFloat指向int n = 9这块空间，把9.0放进*pFloat
	printf("num的值为：%d\n", n);/打印n的值,以%d形式打印的
	printf("*pFloat的值为：%f\n", *pFloat)//打印*pfloat（把pfloat解引用一下，得到一个值），
                                           这个值以%f的形式打印
	return 0;
}


结果：
n的值为：9
* pFloat的值为：0.000000
num的值为：1091567616
* pFloat的值为：9.000000






1.printf("n的值为：%d\n", n);/上面我们把n以int形式放到float类型里面，
	这里打印的时候以%d形式打印，在把n从float类型中把他拿出来，是int类型

2.printf("*pFloat的值为：%f\n", *pFloat);/这里是把n以int形式放进去，
	                 再以浮点数的形式往出拿，再以浮点数的形式打印

上面这两段说明整形在内存中存储进去之后，他以浮点数的形式往出拿得时候，拿出的结果和以整形的形式
往出的的结果不一样。说明在内存中存储数据的时候，以整形的形式往出取和以浮点数的形式往出取是不一样
的（整形在内存中的存储和浮点数在内存中的存储不一样）。







3.*pFloat = 9.0;/通过浮点数的指针（*pFloat），去访问字节，在这四个字节的n里面放了9.0进去，
                                    这是以浮点数的视角往进放
4.printf("num的值为：%d\n", n);//放进去之后，以整形的形式往出拿，发现拿出来的不是9，
                                      说明整形和浮点数在内存中的存储是不一样的
5.printf("*pFloat的值为：%f\n", *pFloat);/以浮点数的形式把9.0放进去，以浮点数的形式往出拿，
                                            是9.0

上面说明还是那句话：整形在内存中的存储和浮点数在内存中的存储不一样（以浮点数的形式放进去，要想得到
想要的结果，就要以浮点数的形式往出拿。整形同理）

那么问题来了，既然有差异，浮点型在内存中到底是怎样存储的呢？

3.2 浮点数存储规则

num 和 *pFloat 在内存中明明是同一个数，为什么浮点数和整数的解读结果会差别这么大？
要理解这个结果，一定要搞懂浮点数在计算机内部的表示方法。
详细解读：
根据国际标准IEEE（电气和电子工程协会） 754，任意一个二进制浮点数V可以表示成下面的形式：

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

浮点数V可以这样表示：

就是说任何一个浮点数V可以写成以下这样。

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

当这里的S表示0的时候，这个V是正数。S是1的时候（-1的1次方就是-1，乘后面的数就是负数），这个V是负数。

M表示有效数字，大于等于1，小于2，2^E表示指数位

可能这里大家还是不理解，没关系，下面带你找到答案。

我们在写代码的时候，会写出各种各样的浮点数，比如说：5.5

5.5 - 是10进制的浮点数

把他写成二进制浮点数（要把小数点前和小数点后分开写）

小数点前的5（101），小数点后应该写成1 ，5.5的二进制的浮点数就是--->101.1

101.1这个浮点数写成科学计数法表示是1.011*2^2(因为小数点向左移动了两位）

假设下面是二进制的浮点数（他每一位都有他的权重）：

1 0 1 . 1

小数点后面的那个1的权重是1*2^-1（1x2的-1次方），就是1*1/2^1=1/2=0.5

如果说这个小数点后面还有一位，就是1*2^-2（1x2的-2次方），再有1就是2的负3次方...

101中倒数第一个1是1*2^0,

101中倒数第二个0是0*2^1

101中倒数第三个1是1*2^2

第一个1*2^0是1，第三个1*2^2是4，两个一加是5

所以当V=5.5时，把他写成科学计数法时是：

=（-1）^0*1.011*2^2 前面的（-1）指正否，（-1）^0是正数

此时我们可以总结出来：

S=0

M=1.011

E=2

下面再举个例子：

如9.0

二进制是：1001.0

V=9.0

=(-1)^0*1.001*2^3

S=0

M=1.001

E=3

所以，浮点数在存储的时候，只存储S,M.E即可。

IEEE 754规定：

对于32位的浮点数，最高的1位是符号位S，接着的8位是指数E，剩下的23位为有效数字M（意思是对于float类型的数来说，32 -->float类型）。

(float类型向内存申请了4个字节，这四个字节怎么用呢？如上最高的1位（红色）是符号位S，接着的8位（绿色）是指数E，剩下的23位（紫色）为有效数字M）

对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M（意思是对于double类型的数来说，64 -->double类型） .

（double类型向空间申请了8个字节，这8个字节怎么用呢？对于64位的浮点数，最高的1位（红色）是符号位S，接着的11位（绿色）是指数E，剩下的52位（紫色）为有效数字M）

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

（S的话，要么放0进去，要么放一进去，没有什么特殊规定）

前面说过， 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。

这意味着，如果E为8位，它的取值范围为0~255；如果E为11位，它的取值范围为0~2047。但是，我们知道，科学计数法中的E是可以出现负数的是什么意思呢？

比如有一个数字是0.5，这是10进制的浮点数，现在要把它写成二进制的浮点数是0.1

把0.1写成科学计数法的表现形式就是1.0（把小数点向右移动一位）.1.0*2^-1，加上正负号就是（-1）*1.0*2^-1

S=0

M=1.0

E=-1

我们发现当0.5换算成科学计数法的形式的时候E可能是负数（本来IEEE 754认为在32位的float类型里面这8个绿色的E是无符号数。在64位的double类型里面这11个绿色的E是无符号数,他认为是无符号数的时候里面只能存正数，但是我们发现真实的E可能是负数，如上，所以这个地方为了修正它，怎么做的呢？往下看）

所以IEEE 754规定，存入内存时E的真实值必须再加上一个中间数，对于8位的E，这个中间数是127（float加中间值是127）；对于11位的E，这个中间数是1023（double加中间值是1023）。什么意思呢？

如下当我们现在明确知道我们是float类型的数字

当我们存S的时候，S=0，把0存进去（红色部分），然后紧接着下来8个存E，E是-1，那是不是直接把-1放进去，其实不是的而是让E加上一个中间值127等于126，把126存到E里面。这里加上127相当于修正，把这个负数变成正数，因为站在IEEE 754这个角度，这个E只能存正数。

而对于double类型来说，这个修正的数字是1023，如下：

这里32和64位不管E是正数负数，往进存的时候都要加127和1023，同理，往出拿得时候都要减127和1023.

那是不是如上说的那样呢？接下来我们测试一下。

int main()
{
	float f = 5.5;
	/(二进制表现形式）101.1
	/1.011 * 2^2
	/（科学计数法表现形式）(-1)^0 *1.011 * 2^2
	/S = 0
	/M = 1.011
	/E = 2
	 
	/ E+127=129  （129的二进制100 0000 1）
	/ 对于M只存小数点后的数，是011，但是前面我们说M要存23个比特位，这里只有三个，后面直接补0
	/0100 0000 1011 0000 0000000000000000     （那这里是不是存进去之后是这个数呢？我们把他转化 
     /成16进制，看内存中是否一样）
	/0100->4     0000->0    1011->11(b)
	/这里转化成16*/进制是这样的：0x40b00000
	return 0;
}

我们发现，答案是正确的。

上面讲了一个浮点数的V怎么拆成二进制的科学计数法表现形式，这个S,M和E是怎么回事，当我们把S,M,E相关的值存到内存里面是怎么存的，这一点我们理解了。当我们理解怎么放进去的，也应该明白一个问题，怎样把他从内存中取出来，那怎么把他从内存中取出来呢？接着往下看。

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

E不全为0或不全为1（绝大部分情况）

这时，浮点数就采用下面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将
有效数字M前加上第一位的1。
比如：
0.5（1/2）的二进制形式为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全为1

这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）；
好了，关于浮点数的表示规则，就说到这里。

此时，来个例子，为什么打印的结果是那样的，如图：


int main()
{
	int n = 9;
	
	/0 00000000 00000000000000000001001
	/S  E        M
	/0  -126     0.00000000000000000001001
	/(-1)^0 * 0.00000000000000000001001 * 2^-126
	/
	/E在内存中是全0
	
	float* pFloat = (float*)&n;

	printf("n的值为：%d\n", n);/9以整形的形式放进去，以整形的形式打印

	printf("*pFloat的值为：%f\n", *pFloat);/0.000000   这里当我们发现，用 pFloat访问内存里 
    空间的数据的时候，是以浮点数的视角看待他的，*pFloat是站在float* pFloat = (float*)&n中 
    pFloat来看待n这四个字节的，此时，*pFloat就认为他指向的这块内存空间里面放的是浮点数，此时，他 
    认为（如上代码二进制）最高位0是符号位S，00000000这8个比特位是E，00000000000000000001001这 
   个就是小数点后面的位M，此时我们发现E在内存中是全0，我们上面说，当E为全0的时候，浮点数的指数E 
   等于1-127（或者1-1023）即为真实值，所以，这个E直接就还原成-126，有效数字M不再加上第一位的1， 
   而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于 0的很小的数字（0.00000000000000000001001），还原出来之后就是(-1)^0 * 0.00000000000000000001001 *2^-126，这是一个非常小的数字，而这里以%f的形式打印，但他只能打印小数点后6位，所以是0.000000.

	*pFloat = 9.0;
当前面的代码了解之后，n还是前面的n，4个字节，*pFloat 还是访问4个字节，但是这一次是以浮点数的视角往进放了个9.0，而9.0的二进制序列如下1001.0
	/1001.0
	/1.001 * 2^3  科学计数法表现形式
	/(-1)^0 * 1.001 * 2^3    加上正负
	/S=0     E=3  M=1.001
	/0 10000010 00100000000000000000000
	
	printf("num的值为：%d\n", n);//1091567616
    以整形的形式打印，就是要把上面0 10000010 00100000000000000000000这个数字转化成10进制

	printf("*pFloat的值为：%f\n", *pFloat);//9.0
    以浮点数的形式打印
	return 0;
}