数据在内存中的存储

主要研究整型和浮点型在内存中的存储。

1. 整数在内存中的存储

在学习操作符的时候，就了解过了下面的内容：

整数的2进制表示方法有三种，即原码、反码和补码。

有符号的整数，三种表示方法均有符号位和数值位两部分，符号位都是用0表示“正”，用1表示“负”，最高位的一位是被当做符号位，剩余的都是数值位。

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

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

• 原码：直接将数值按照正负数的形式翻译成二进制得到的就是原码。

• 反码：将原码的符号位不变，其他位依次按位取反就可以得到反码。

• 补码：反码+1就得到补码。

整数有原码、反码、补码三种表示方法，但是在内存中的是补码，其中计算用的内存中的二进制，使用的也就是补码。

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

为什么呢？

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

原因在于，使用补码，可以将符号位和数值域统一处理；

同时，加法和减法也可以统一处理（CPU只有加法器）。此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。

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

当我们了解了整数在内存中存储后，我们调试看一个细节：

#include <stdio.h>

int main()
{
    int a = 0x11223344;
    
    return 0;
}

一个十六进制位*（8 4 2 1）*等于四个二进制位，所以其中11占一个字节，22占一个字节以此类推。所以11223344总共占了四个字节，将这个四个字节数据存进a中，可以将int类型的a填满。

调试的时候，我们可以看到在a中的 0x11223344 这个数字是按照字节为单位，倒着存储的。这是为什么呢？

补充：有关数据存储的问题只需要保证最终在使用数据时可以将数据拿出来使用就可以，所以只要保证可以拿出数据理论上任何存储方式都是可以的，但是为了保证可以合理的拿出数据进行使用产生的下面两种存储方式。

2.1 什么是大小端？

其实超过一个字节的数据在内存中存储的时候，就有存储顺序的问题，按照不同的存储顺序，我们分为大端字节序存储和小端字节序存储，下面是具体的概念：（以字节为单位讨论他们的存储顺序的）

• 大端（存储）模式：（顺着排）
  是指数据的低位字节内容保存在内存的高地址处，而数据的高位字节内容，保存在内存的低地址处。

• 小端（存储）模式：（逆着排）
  是指数据的低位字节内容保存在内存的低地址处，而数据的高位字节内容，保存在内存的高地址处。

上述概念需要记住，方便辨别大小端。

如上图所示，由于11 为高位字节，并在内存中存放在高位地址中，而且是逆着排的，所以VS中的存储方式是小端（存储）模式。

2.2 为什么有大小端?

为什么会有大小端模式之分呢？

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

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

因为内存中的一个内存单元的大小就是一个字节，这时存储超过一个字节的数据，就需要将多个字节的数据切成一个个字节进行存放，所以切开数据就会产生大小端的问题。

2.3 练习

2.3.1 练习1（判断当前机器的字节序）

简述大端字节序和小端字节序的概念，设计一个小程序来判断当前机器的字节序。

//代码1
#include <stdio.h>
int check_sys()
{
    int i = 1;
    return (*(char *)&i);	//返回1是小端模式，返回0是大端存储
}

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

补充：

• 这里是int i = 1，实际在内存中存储的方式是0x00 00 00 01，四个字节存储

• 只需要将四个字节中的第一个字节取出，再判断是00还是01即可判断出存储方式

• 因为变量i是int类型，如果直接取地址就是int*就会从首地址往后取四个字节，但是只需要对首地址后面的第一个字节进行判断即可，所以可以对i取地址，再强转成char*类型即可实现

• 在对第一个字节的地址进行解引用，即可取出排列在内存首位的一个字节的数据，即可进行判断

注意：

1. 这里不直接强制转化成char的原因是，强制转化有其自己的逻辑，他会取出int类型中的四个字节中有效数字，所以无法保证取出的数据的位置，也就没有办法确定存储方式。

2.3.2 练习2（整型提升与占位符%d）

#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的打印：

• 在C语言中char，是否有符号是不确定的，这个取决于编译器，但是大部分编译器char == signed char

• 由于-1是整型类型， 再赋值给char a时，需要发生一些变化 -1的原码：10000000000000000000000000000001 -1的反码：11111111111111111111111111111110 -1的补码：11111111111111111111111111111111（在内存中存储的形式）

但是因为需要将其放进一个字节的内存空间中去存储，所自然选择第一个字节的8位bit位(11111111)放进char a中

• 下面的printf语句中的**%d表示打印有符号的整数，%u打印无符号整数**，所以在打印a时需要发生整型提升，这里的s的类型是有符号的char类型，这里的最高位则默认补符号位，所以对其进行整型提升的时候高位补符号位即可。 则最后整型提升的结果是11111111111111111111111111111111

这里整型提升的结果是在内存中的补码，但是打印的时候需要打印原码，随后则对整型提升的补码求其原码 原码为：10000000000000000000000000000001

也就是-1，所以最后打印的结果是a = -1。

**b的打印：**因为VS中char == signed char所以b的打印与a的打印同理。

c的打印：

前面的分析与a的打印一样，但是在进行整型提升的结果产生差异

因为c的类型是unsigned char，在对于无符号的char类型进行整型提升的时候直接在高位补0即可。

最后整型提升的结果是：00000000000000000000000011111111

同时因为是无符号类型，原码反码和补码都一样，在利用printf函数打印的时候直接打印，将二进制转化成十进制为255。

2.3.3 练习3（整型提升与占位符%u）

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

运行结果：

说明：

• -128的原码：10000000000000000000000010000000 -128的反码：11111111111111111111111101111111 -128的补码：11111111111111111111111110000000

因为需要将-128这个整数放进char类型的a进行存储，取最低的8位在内存中存储也就是10000000 放进char a中

• 因为printf函数适用于打印整数，所以需要对char类型的a进行整型提升，因为VS中char == signed char，整型提升需要在高位补上符号位，所以最后整型提升的结果：11111111111111111111111110000000

• 这里的printf函数利用的占位符是%u，意思是打印无符号整数，以%u的角度认为内存中存储的是无符号整数。 所以对于整型提升之后存放在内存中的数据11111111111111111111111110000000，直接默认为是无符号整数，其原码反码补码都一样，所以直接将其转化成十进制输出为4294987168。

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

说明：运行结果和分析思路与上面的代码一致

因为char类型的存储范围是-128~127，所以该代码中的a存不下128。

补充：

为什么char类型的存储范围是-128~127

因为VS中char == signed char，所以下面8位数据的首位数据都是符号位，其中1开头的数据转化为十进制，需要将其从反码转化为原码

注意10000000 其不能按照常规的将补码转化为原码的思路计算，因为其反码为11111111，+1后需要进位，所以直接将其翻译为-128

第二个代码中的128存不下，所以就相当于是往里放了-128，这就是第一个和第二个代码运行结果一样的原因。

为什么unsigned char类型的存储范围是0~255

因为是无符号类型，其中的8位数据都是有效位

以此类推，short、int等类型的存储范围都可以用这种思路的方式算出。

补充：signed int 和unsigned int 的作用

其实signed int 和unsigned int 都可以在内存中开辟相同的四个字节的空间进行存放数据，只是signed规定最高位为符号位，但是unsigned规定最高位不是符号位，他们都有能力存放相同四个字节的数据，无论数据是否可以存下，他们只负责将对应的数据放进自己的存储空间中，至于如何使用他们存放的数据是程序员自己应该做出的决定。

int main()
{
    signed int num = -10;
    printf("%d",num);
    printf("%u",num);
    return 0;
}

输出结果：

所以根据上述代码，站在%d的角度去解读num中的数据，反映出来的结果就是-10；站在%u的角度去解读num中的数据，反映出来的结果就是4294987168。如何去使用内存中的数据、以怎样的视角去看待存放在内存中的数据是很重要的，与数据是什么类型是否带有符号关系不大。

同样如果将上面的代码中的signed int 改成 unsigned int 输出的结果还是不会改变。

类型的作用还是像内存申请一块空间，然后将数据放入，所以如何看待内存中的这串数据才是更重要的。

但是代码的编写需要有意义，一般signed int 的变量就用%d打印，unsigned int 就用%u打印。

2.3.4 练习4（类型的范围循环逻辑、测试一个类型的存储范围）

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

说明：

• 上述程序主要是利用for循环不断向char[1000]类型数组a中，从-1开始不断递减的存储进数据。

• 由于strlen函数的作用是求字符串的长度，统计\0（数值0）之前的字符个数，所以按照正常思路（下图方框中的红色数字）由-1不断递减存入数组a中，所以该数组中没有出现数值0，所以返回值无法计算。

• 但是因为数组a类型char的限制，结合上面对于类型取值范围的分析，可以知道如果是-1的递减取值的话则是从-1按照圆的逆时针取值放入数组a中（下入方框中的蓝色数字）。

• 根据计算在第一次放入数值0的时候停止计数，所以返回的就是char类型的空间大小也就是255。

2.3.5 练习5（类型的范围循环逻辑）

#include <stdio.h>

unsigned char i = 0;//全局变量
int main()
{
    for(i = 0;i<=255;i++)//循环256次
    {
        printf("hello world");
    }
    return 0;
}

运行结果：死循环打印 hello world

说明：

由于i是unsigned char 类型，取值范围为0~255，所以i不会大于255循环条件恒成立，故死循环。

#include <stdio.h>

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

运行结果：死循环打印数字

说明：

因为i是unsigned int 类型，取值恒大于0，所以循环条件恒成立，故死循环。

但是，当i < 0后，因为需要打印无符号的整数，故会将-1的补码直接当做原码转成十进制打印在屏幕上，故会是一个很大的数字。

2.3.6 练习6（综合练习）

#include <stdio.h>
//X86环境 小端字节序 
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);
    //%x 是16进制的形式打印
    return 0;
}

运行结果：4,2000000

说明：

• 画出如下思考图，得到ptr1，其中因为&a +1的类型是int(*)[4]，但是prl1的类型是int(*)，如果需要二者进行赋值操作则需要进行类型的强制转化；另外&a + 1代表跳过整个数组的地址，并不是只跳过数组中的一个元素。 下面ptr1[-1]等价为*（ptr1-1）由于ptr1是整型指针，-1则相当于地址向低地址偏移4个字节，指向如图位置为0x4，打印出结果为4

• 对于ptr2首先对数组名也就是首元素地址强制转化为int类型，在对这个整数+1，运算之后得到的数与起始地址相差一个字节，也就是只向高位偏移1个字节，这时需要了解数组中每个字节的数据情况，画出下面的分布图，注意题目要求按照小端字节存储方式分布。根据图像，（（int）a + 1）表示起始地址向高位偏移1个字节的地址指向01后面的地址，此时对其强制转化成（int*）整型指针；下面printf语句中对ptr2解引用，对整型指针解引用需要访问四个字节（00 00 00 02），同时因为存方式是小端存放，还原成真实值就是02 00 00 00，所以打印结果为2000000

• 如果想打印成0x4,0x2000000 可以将占位符%x改成%#x即可。

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

常见的浮点数：3.14159、1E10（科学计数法）等，浮点数家族包括：float、double、long double类型。

浮点数表示的范围：float.h中定义。

3.1 练习

#include <stdio.h>

int main()
{
    int n = 9;
    float *pFloat = (float *)&n;
    printf("n的值为：%d",n);
    printf("*pFloat的值为：%f",*pFloat);

    *pFloat = 9.0;
    printf("num的值为：%d",n);
    printf("*pFloat的值为：%f",*pFloat);
    return 0;
}

运行结果：

n的值为：9 *pFloat的值为：0.000000

n的值为：1091567616 *pFloat的值为：9.000000

说明：

• 上半部分的代码中，将9以整数的格式存储进整型变量中，再用整数的格式打印可以打印出整数9，但是在以浮点数的格式打印时却不是9.0，这就说明整数和浮点数的存储方式是不一样的，因为以整型的形式放进去看，以浮点型的形式拿出来的结果却不一样。并且在下半部分的代码中，以浮点型的数据放进内存中，在以整型的形式拿出打印的时候打印的却是1091567616，但是以浮点型的形式放入以浮点型的形式拿出却可以正常打印出9.0，结果正确。（整数和浮点数在内存中的存储方式是有区别的）

3.2 浮点数的存储

上面的代码中，num和*pFloat在内存中明明是同一个数，为什么浮点数和整数的解读结果会差别这么大？

要理解这个结果，一定要搞懂浮点数在计算机内部的表示方法。

根据国际标准IEEE（电气和电子工程协会）754，任意一个二进制浮点数V可以表示成下面的形式：

$V=(-1{)}^S\ast M\ast 2^E$

• S表示符号位，当S=0，V为正数；当S=1，V为负数；
• M表示有效数字，M是大于等于1，小于2的；
• $2^E$表示指数位 。

举例来说：

十进制的5.5，写成二进制是 101.1*（按照位权的概念这里小数点后面的1代表2^-1）*

相当于 $1.011\times 2^2$（在二进制的基础上左移几位，在科学计数法中就在后面乘2的几次方）。

那么，按照上面V的格式，可以写出公式为$(-1{)}^0\ast 1.011\ast 2^2$，可以得出S = 0，M = 1.011，E = 2

十进制的-5.0，写成二进制是-101.0，相当于-$1.01\times 2^2$ 。那么S = 1，M = 1.01，E = 2。

任何浮点数V都可以化成上述的二进制数，这样只需要存储S、M、E即可

所以浮点数的存储，存储的是S、M、E 相关的值。

IEEE 754规定：

• 对于32位的浮点数（float类型），最高的1位存储符号位S，接着的8位存储指数E，剩下的23位存储有效数字M；
• 对于64位的浮点数（double类型），最高的1位存储符号位S，接着的11位存储指数E，剩下的52位存储有效数字M。

float类型浮点数的分配

double类型浮点数内存分配

3.2.1 浮点数存的过程

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

前面说过，1<M<2, 也就是说，M 可以写成 1.xxxxxxxxx的形式，其中 xxxxxxx表示小数部分。

IEEE754 规定，在计算机内部保存 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 是可以出现负数的，所以 IEEE754 现定，存入内存时 E 的真实值必须再加上一个中间数，对于 8 位的 E, 这个中间数是 127; 对于 11 位的 E, 这个中间数是 1023。比如，2^10的 E 是10, 所以保存成 32 位浮点数时，必须保存成 10+127=137, 即 10001001。

这里的中间值是为了保证存进内存中的E的数据一定是一个正数。

3.2.2 浮点数取的过程

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

E 不全为 0 或不全为 1（正常情况既有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 的很小的数字。

0 00000000 0010000000000000000000

E 全为 1

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

0 11111111 0001000000000000000000

其中，M部分数据的存储是忽略科学技术法的整数部分的1，将后面的小数部分写到M的区域，再用0补齐后面的0~23位。

3.3 题目解析

#include <stdio.h>

int main()
{
    int n = 9;
    float *pFloat = (float *)&n;
    printf("n的值为：%d",n);
    printf("*pFloat的值为：%f",*pFloat);

    *pFloat = 9.0;
    printf("num的值为：%d",n);
    printf("*pFloat的值为：%f",*pFloat);
    return 0;
}

先看第1环节，为什么9还原成浮点数，就成了0.000000？

9以整型的形式存储在内存中，得到如下二进制序列：

0000 0000 0000 0000 0000 0000 0000 10011//内存中的数据形式

首先，将9的二进制序列按照浮点数的形式拆分，得到第一位符号位S=0，后面8位的指数E=00000000，最后23位的有效数字M=0000000000000000001001。

由于指数E全为0，所以符合E为全0的情况。因此，浮点数V就写成：

V=(-1)^0 * 0.00000000000000000001001 * 2^(-126) = 1.001 * 2^(-146)

显然，V是一个很小的接近于0的正数，所以用十进制小数表示就是0.000000。

再看第2环节，浮点数9.0，为什么整数打印是1091567616？

首先，浮点数9.0等于二进制的1001.0，即换算成科学计数法是：1.001×2^3

所以:$9.0=(-1{)}^0\ast (1.001)\ast 2^3$,

那么,第一位的符号位S=0,有效数字M等于001后面再加20个0,凑满23位,指数E等于3+127=130,
即10000010

所以,写成二进制形式,应该是S+E+M,即

 0 10000010 001 0000 0000 0000 00000 0000//内存中的数据形式

这个32位的二进制数,被当做整数来解析并用于打印的时候,就是整数在内存中的补码,原码正是1091567616。

所以在打印数据的时候一定要注意占位符的使用，有符号的整数就应该用%d、无符号的整数就应该用%u、浮点数就应该用%f。错误的使用占位符也会打印出错误的形式。原因就是不用的占位符是从不同的角度看待内存中的数据。

造成在内存中相同的数据，打印出来的结果却不同的原因归根结底还是从何种角度去看待这些在内存中的数据。