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

目录

本章重点

一、数据类型的详细介绍

        1.1 类型的基本归类：

二、整形在内存中的存储

2.1 原码、反码、补码

2.2大小端介绍

2.3数据储存的练习

2.3.1.该函数输出什么

2.3.2.下面程序输出什么？

2.3.3.下面程序输出的是什么？

2.3.4.下述程序运行的结果是什么？

 2.3.5.下述程序运行结果是什么？

2.3.6.下述程序运行的结果是什么？

2.3.7.下述程序运行的结果是什么

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

3.1浮点数存储规则

案例分析

---

本章重点

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

---

一、数据类型的详细介绍

char           //字符数据类型  1个字节

short          //短整型     2个字节

int              //整型         4个字节

long           //长整型     4个字节

long long   //更长的整型  8个字节

float           //单精度浮点型  4个字节

double      //双精度浮点型   8个字节

以上的数据都是由64位机得来

下面进行数据测试：

当我们得知各种数据类型的字节大小时，我们就可以利用不同的数据字节大小进行不同的计算

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]

浮点数家族：

float
double

构造类型：

数组类型

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

指针类型：

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

空类型：

void用于表示空类型（无类型）

通常应用于函数的返回类型、函数的参数、指针类型

---

二、整形在内存中的存储

一个变量的创建是要在内存中开辟空间的，空间的大小是根据不同的类型而决定的。
那接下来我们谈谈数据所开辟内存中到底是如何储存的
比如：

int a = 20;
int b = -10;

我们知道为 a,b分别分配四个字节的空间。
那如何存储？

下面需要了解以下概念：

2.1 原码、反码、补码

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

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

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

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

原因在于，使用补码，可以将符号位和数值域统一处理；同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的（补码取反+1=原码），不需要额外的硬件电路。
接下来看内存中具体的储存情况：

 可以看到内存中的存储确实存放的是补码，但是我们发现存放的顺序和我们计算的顺序是不一样的，这个为什么呢？

2.2大小端介绍

什么是大小端：

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

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

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

 接下来我们简单设计一个小程序来判断当前机器的字节序

可以看到我当前的机器是小端机器。

2.3数据储存的练习

2.3.1.该函数输出什么

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进行分析： 

 首先a是负数，储存的补码是
10000000 00000000 00000000 00000001 - 原码
11111111 11111111 11111111 11111110 - 反码
11111111 11111111 11111111 11111111 - 补码
char类型为一个字节，当给char一个整数时会发生截断
截断 11111111 - char
但是打印时为%d打印 即有符号整型打印，那么截断之后要整型提升，提升看符号位
11111111 11111111 11111111 11111111 - 提升之后的补码
打印之后显示的是原码，将上述补码+1得到打印值 即-1

对b进行分析：

signed char 与 char 等价
所以同上理 b打印值为 -1

对c进行分析：

首先c为负
10000000 00000000 00000000 00000001 - 原码
11111111 11111111 11111111 11111110 - 反码
11111111 11111111 11111111 11111111 - 补码
截断 11111111 - char
%d打印时为有符号打印，这里需要整型提升，但是c为unsigned所以整型提升补0
00000000 00000000 00000000 11111111
这里提升为正数 原、反、补相等 计算得255

 

最后通过编译器证明分析无误

2.3.2.下面程序输出什么？

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

 对c分析：

10000000 00000000 00000000 10000000 - 原码
11111111 11111111 11111111 01111111 - 反码
11111111 11111111 11111111 10000000 - 补码
截断 10000000 - char
整型提升 11111111 11111111 11111111 10000000
%u为无符号整型打印 所以直接计算打印此二进制数

 

 最后经过计算得到的结果和程序运行的结果一致，证明此处分析正确

2.3.3.下面程序输出的是什么？

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

对a分析： 

首先a为正数 原、反、补相同
00000000 000000000 00000000 10000000 - 补码
截断 10000000 - char
因为char是有符号的，所以整型提升看符号位
整型提升 - 11111111 11111111 11111111 10000000
%u无符号打印 

 可以看出计算结果和程序运行结果一致，证明分析没有错误

2.3.4.下述程序运行的结果是什么？

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

对i分析：

首先i是负数 
10000000 00000000 00000000 00010100 - 原码
11111111 11111111 11111111 11101011 - 反码
11111111 11111111 11111111 11101100 - 补码 

 对j分析：

j是正数 原、反、补相等
00000000 00000000 00000000 00001010 - 补码

对i+j分析：

i补码 - 11111111 11111111 11111111 11101100 - 补码 

j补码 - 00000000 00000000 00000000 00001010 - 补码

i+j：11111111 11111111 11111111 11110110 -负数补码要转化为原码
%d打印有符号整数
10000000 00000000 00000000 00001010 -原码

最终结果-10

这里值得注意的是不管一开始相加的两个数是否有符号，最终的结果取决于最后打印的要求

程序的运行结果与分析结果一致，说明分析无误

 2.3.5.下述程序运行结果是什么？

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

 程序分析：

首先i是一个无符号的整型
这里就说明了i永远不可能小于0，所以程序会死循环运行
又因为打印的是%u为无符号整数，所以打印的结果将会是 9 8 7 6 5 4 3 2 1 0

当i=-1时

10000000 00000000 00000000 00000001 - 原码

111111111 111111111 111111111 111111110 - 反码

111111111 111111111 111111111 111111111 - 补码

但是这里的i是无符号数 所以这里的i计算结果就是一个很大的数

然后程序死循环打印

 

 

2.3.6.下述程序运行的结果是什么？

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

首先对a[]数组分析，这是一个字符数组，储存的只有一个字节
将a[i]储存的时候就会发生截断
而有符号的 char数据范围是 -128~127
所以a[]数组中储存的数据为-1 -2...-128 127 126 ...0
而strlen遇到\0停止计数，所以最后的结果为255 

这里将题目做了一些修改，方便查看a[]数组中的元素 

通过程序的运行最后也是得到了255这个答案，说明上述的分析没有问题

2.3.7.下述程序运行的结果是什么

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

程序分析： 

首先对i进行分析，i是一个无符号的char类型
无符号的char取值范围是0~255
所以i无论如何都不可能大于255，程序会死循环

---

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

3.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。
IEEE 754规定：

对于32位的浮点数，最高的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。

 

然后，指数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;
    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;
}

 对float *pFloat = (float *)&n进行分析：

首先对n分析：n是一个正整数
00000000 00000000 00000000 00001001 - 补码
而将n强制类型转换为float*型时，数据储存为
0 00000000 00000000000000000001001
经计算 (-1)^0 * 0.00000000000000000001001 * 2^-126
所以此处计算的*Float为0.000000

对*pFloat = 9.0进行分析：

当*pFloat为9.0时
s=0

1001相当于1.001x2^3
M=1.001
E=3
所以储存的数据是 0 10000010 00100000000000000000000
而整型n读取时为 01000001 00010000 00000000 00000000
此二进制数为正数所以原、反、补都相同

计算得：

最后程序运行的结果：

通过程序运行结果与计算结果对比说明分析无误

---

总结

上述就是对数据在内存中的存储的一个分析，大致可以分为

1.数据类型介绍

2.整型在内存中的储存

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