（由浅入深）带你一步一步走入内存中的世界

（由浅入深）带你一步一步走入内存中的世界

目录

一. 数据类型介绍

1.类型的基本归类：

二. 整形在内存中的存储

1 .原码、反码、补码

2.大小端介绍

（1）什么是大端小端：

（2）为什么有大端和小端：

（3）判断当前机器的字节序

（4）练习题

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

1.浮点数存储规则

（1）IEEE 754规定：

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

（3）至于指数E，情况就比较复杂。

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

2.练习题

---

前言：我们在面对内存那一串密密麻麻的数字，只是觉得很烦，不知道那其中的奥妙，今天呐，我将要带大家一起去了解数据是如何在内存中存储的，并且让我们可以看懂内存，增加我们的内功，为学习打下更加坚实的基础。

一. 数据类型介绍 前面我们已经学习了基本的内置类型：

                                                   大小 char              字符数据类型          1 short              短整型                     2 int                  整形                         4 long               长整型                     4 long long       更长的整形              8 float               单精度浮点数          4 double           双精度浮点数          8

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 ]

 浮点数家族：

float double

构造类型：

 数组类型

 结构体类型 struct

 枚举类型 enum

> 联合类型 union

指针类型：

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

空类型：

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

二. 整形在内存中的存储

在了解整形存储之前，我们首先要知道原码、反码、补码的概念。

1 .原码、反码、补码 计算机中的整数有三种表示方法，即原码、反码和补码。 三种表示方法均有 符号位 和 数值位 两部分，符号位都是用 0 表示 “ 正 ” ，用 1 表示 “ 负 ” ，而数值位 负整数的三种表示方法各不相同。

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

正数的原、反、补码都相同。 对于整形来说：数据存放内存中其实存放的是补 码。 存在原码、反码、补码的原因：

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

2.大小端介绍 （1）什么是大端小端：

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

比如：0x11223344

                         低地址                            高地址

大端存储为：                11   22   33   44

小端存储为：                44   33   22   11

（2）为什么有大端和小端：

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

（3）判断当前机器的字节序

#include 

int check_sys()
{
    int i = 1;
    return (*(char *)&i);
}

int main()
{
    int ret = check_sys();
    if(ret == 1)
    {
        printf("小端n");
    }
    else
    {
        printf("大端n");
    }
    return 0; 
}

此时我们会发现结果为    小端。 （4）练习题

了解了整形的存储后，我们用几道练习题来加强认识。

1.

#include 

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  -1  255

大多数情况下默认char就是signed char ，所以a，b是一样的，

-1的原码为：10000000   00000000   00000000   00000001

-1的反码为：11111111     11111111     11111111     11111111

-1的补码为：11111111     11111111     11111111     11111111

存储到char类型中要发生截断，因此a，b中存储的数据为11111111，打印a和b时打印的是%d形式要发生整型提升，应补最高符号位到32位，就又变成了 11111111 11111111 11111111 11111111，但此时这个二进制是补码，打印时要变成原码，变成10000000 00000000 00000000 00000001 ，即-1.

而c为255，因为c的类型是无符号（unsigned）char类型，-1的补码11111111 11111111 11111111 11111111截断后变为11111111，打印时发生整型提升，又因为无符号，所以整型提升时不认同1，要补0， 即00000000 00000000 00000000 11111111，而正数的原码和补码相同，所以这就是c的原码，转换为十进制打印即是255.

2.

#include 

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

结果为4294967168

-128的补码是11111111 11111111 11111111 10000000，发生截断后存储到c中的是10000000
因为a是有符号char，又因为后面要打印，所以发生整型提升，且补最高位符号位1,整型提升后变为11111111 11111111 11111111 10000000。又要以%u形式打印，所以此时的补码就等于原码，因此就打印11111111 11111111 11111111 10000000对应的十进制数，即4294967168.

3.

#include 

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

结果为4294967168

与第二题类似，这里只是把a从-128变成了128，128的原码为10000000 00000000 00000000 10000000，正数的原码、反码、补码相同，要打印就发生截断，a变为10000000，此时后面与上一题相同，都要补1，然后因为%u打印，补码相当于原码，直接打印11111111 11111111 11111111 10000000对应的十进制数，即4294967168.

4.

#include 

int main()
{
	int i = -20;
	unsigned int j = 10;
	printf("%dn", i + j);
	return 0;
}

结果为-10

-20的补码：    11111111  11111111   11111111   11011000
10的补码：     00000000 00000000 00000000 00001010
相加后补码：  11111111   11111111   11111111   11110110
转换为原码 ： 10000000 00000000 00000000 00001010  

转换为十进制结果为：-10

5.

#include 

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

结果会死循环打印，9 8 7 6 5 4 3 2 1 0 4294967295 4294967294......

因为unsigned是无符号数，又要让i>=0，所以一定会死循环，

而当i变为0，再i--时，正常应该变成-1，

-1的补码为11111111 11111111 11111111 11111111，但是要打印无符号数，所以不认同符号位的1，

所以结果就为11111111 11111111 11111111 11111111对应的十进制的正结果，即4294967295.

6.

#include 

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

结果为255（128+127=255）

---

有符号的char类型是-128~127，无符号的char类型的范围是0~255.

strlen遇到0就会停止，但不包括0，因此i从0开始，第一个数为-1-0=-1，接着为

-2 -3 ... -127 -128 127 126... 2 1 0，此时不算0一共有255个.

7.

#include 

unsigned char i = 0;

int main()
{
	for (i = 0; i <= 255; i++)
	{
		printf("hello worldn");
	}
	return 0;
}

结果为死循环。

因为无符号类型的char的范围是0~255，永远<=255，所以会死循环的打印下去。

三. 浮点型在内存中的存储 1.浮点数存储规则

根据国际标准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 ，相当于 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 。 （1）IEEE 754规定： 1.对于32 位的浮点数，最高的 1 位是符号位 s ，接着的 8 位是指数 E ，剩下的 23 位为有效数字 M 。 2.对于 64 位的浮点数，最高的 1 位是符号位S，接着的 11 位是指数 E ，剩下的 52 位为有效数字 M 。 （2）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 位有效数字。 （3）至于指数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 从内存中取出还可以再分成三种情况：

1.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  

2.E全为0

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

3.E全为1

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

2.练习题

#inlucde 

int main()
{
	int n = 9;
	float* pFloat = (float*)&n;
	printf("n的值为：%dn", n);
	printf("*pFloat的值为：%fn", *pFloat);
	*pFloat = 9.0;
	printf("num的值为：%dn", n);
	printf("*pFloat的值为：%fn", *pFloat);
	return 0;
}

结果为9            0.000000            1091567616            9.000000 那么为什么会有这个输出结果呢： 为什么0x00000009 还原成浮点数，就成了 0.000000 ： 首先，将 0x00000009 拆分，得到第一位符号位 s=0 ，后面 8 位的指数 E=00000000 ，最后 23 位的有效数字M=000 0000 0000 0000 0000 1001。

9 -> 0000 0000 0000 0000 0000 0000 0000 1001

由于指数 E 全为 0 ，所以符合上一节的第二种情况。因此，浮点数 V 就写成： V=( - 1)^0 × 0.00000000000000000001001×2^( - 126)=1.001×2^( - 146) 显然， V 是一个很小的接近于 0 的正数，所以用十进制小数表示就是 0.000000 。 浮点数 9.0 ，如何用二进制表示？还原成十进制又是多少呢 首先，浮点数 9.0 等于二进制的 1001.0 ，即 1.001×2^3 。 那么，第一位的符号位 s=0 ，有效数字 M 等于 001 后面再加 20 个 0 ，凑满 23 位，指数 E 等于 3+127=130 ， 即10000010 。 所以，写成二进制形式，应该是 s+E+M ，即 这个32 位的二进制数，还原成十进制，正是 1091567616 。

0 10000010 001 0000 0000 0000 0000 0000

这个 32 位的二进制数，还原成十进制，转换后就是 1091567616。 好啦，本篇对于内存的学习就到此结束了。