【数据的存储：C语言进阶（Day 1）】

数据类型介绍

前面我们已经学习了C语言的一些内置类型并且知晓了它们所占内存空间的大小：

char         // 字符数据类型   1

short       // 短整型              2

int         // 整形                    4

long         // 长整型             4/8       [C语言规定sizeof(long)>=sizeof(int)即可。

long long   //更长的整形    8         通常认为在32位机器上是4；64位机器上是8]

float       // 单精度浮点数    4

double       // 双精度浮点数 8         

类型的意义：根据不同的数据设计出不同的数据类型，一方面使得数据在内存中的存放更加井然有序，另一方面能尽可能避免内存空间的大量浪费，假设我们只有一种数据类型，它的大小是4字节，而我们要存储一个大小为1字节的数据，用这个数据类型来申请内存空间就会造成3字节的空间浪费。

类型的基本归类

整形家族：

char

unsigned char

signed char

【字符型数据在内存上存的其实是其ASCII码值，也是整数，因此被划分到整形家族中】

short

unsigned short [ int ]

signed short [ int ]

int

unsigned int

signed int

long

unsigned long [ int ]

signed long [ int ]

注意：

*unsigned表示无符号类型、signed表示有符号类型，除字符型外的其他数据类型单独出现时，我们默认它们属于无符号类型，关于char到底是signed char还是unsigned char是C语言标准未定义的，取决于编译器的实现，在VS环境中它被认为是signed char。

*设置signed和unsigned的原因其实源自于我们生活中的实际情况，因为有些数据它一定是正数，如身高、体重、长度等，但有些数据有正有负，如温度等，这样区分在有些情况下能提供方便。

*signed和unsigned的区别在存储上体现为最高位是否有效，signed类型的数据，最高位是符号位，1表示负数、0表示正数而unsigned类型的数据最高位也是有效位。

浮点数家族：

float       单精度浮点型（精度低，存储的数据范围较小）

double   双精度浮点型（精度高，存储的数据范围较大）

注意：

*只要是小数就可以使用浮点型

构造类型：

> 数组类型：

int arr[3]   和int arr[5]也属于两种不同的数据类型，一种是3个整形数据的集合，一种是5个整形数据的集合

> 结构体类型 struct

> 枚举类型 enum

> 联合类型 union

*后续遇到了会详细讲解

指针类型 ：

int * pi ;

char * pc ;

float* pf ;

void* pv ;

*用于存储不同类型数据的地址，其划分的意义在之前的初始C语言笔记中的指针一课有详细讲到

空类型：

void 表示空类型（无类型）

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

*我们在之前的练习中也多次见到过，不再赘述

整形在内存中的存储

我们已经知道内存会更具类型给不同的整形数据分配内存空间，那有了空间，我们存数据的方式又是什么呢？

最最基础的一点我想大家都知道，计算机中所有的数据都是以2进制的方式存在的，因此，无论数据是以什么形式展现出来的，我们都要先将它转换成2进制，才能讨论如何存储的问题，计算机中的整数有三种2进制表示方法，即原码、反码和补码。

三种表示方法均有 符号位 和 数值位 两部分，符号位都是用 0 表示 “ 正 ” ，用 1 表示 “ 负 ” ，最高位是符号位，而数值位

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

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

原码

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

反码

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

补码

反码 +1 就得到补码。

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

为什么呢？

在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统一处理；

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

我们来看一个具体的实例：

想要计算1-1，由于CPU只有加法器，所以我们要把它转化为加法运算，即1+（-1）

原码运算：

1的原码： 00000000000000000000000000000001

-1的原码：10000000000000000000000000000001

原码直接相加：10000000000000000000000000000010 ------答案是-2，错误。

补码运算：

1的补码:00000000000000000000000000000001

-1的补码：11111111111111111111111111111111

补码相加：100000000000000000000000000000000,----因为整形只有32位，最高位1丢失

结果是00000000000000000000000000000000，原码为0，答案正确

由此我们有 结论：内存中的整数都是以其2进制的补码形式存储的

int a=10;

int b=-20

10的原码反码补码相同都是0000000000000000000000000000001010

-20原码10000000000000000000000000010100

-20反码：1111111111111111111111111101011

-20补码;   1111111111111111111111111101100

32位显示起来非常麻烦，因此我们在调取内存时系统会自动将内存中存放的2进制数据转换成16进制的数字，即每4位2进制位变成1位16进制位，最后按字节大小分组展现出来

0000 0000 0000 0000 0000 0000 0000 1010---->00  00  00  0a（按字节分组）

0        0      0        0       0       0       0        a

1111   1111  1111   1111  1111  1111  1110  1100----->ff  ff  ff  ec（按字节分组）

f         f         f         f        f         f       e        c

由图可以观察到内存存数据时并不是按照我们想的顺序存储的，而是按字节从右往左存储的，为什么呢？接下来我们引出大小端的概念。 

大小端介绍

什么大端小端：

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

中；

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

址中。

图例：

 

 为什么有大端和小端：

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

很显然我们当前的硬件环境使我们的数据按照小端字节序的方式存储。

直击面试：

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

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

#include <stdio.h>
int check_sys()
{
   int i = 1;
   return (*(char *)&i);//将i的地址取出然后强制转换为char*的类型，在字符型指针解引用时，               
}                       //只想后读取1个字节，若是大端存储，则读取到00，若是小端存储，则读取到01
int main()
{
 int ret = check_sys();
   if(ret == 1)
    {
     printf("小端\n");
    }
   else
    {
     printf("大端\n");
    }
  return 0; 
}

代码分析：

1、判断当前机器是大端字节序还是小端字节序的本质就是看数据在内存中高位在前还是低位在前，那我们只需要找一个高位和低位不同的整数，然后利用*char解引用指针时只读取一个字节的特性就能轻松实现功能，这里我们选用整数1，它在内存中用16进制表示为

00 00 00 01

电脑读取内存数据时，是（从左到右）从 低位地址 到 高位地址

探究清楚以上一系列问题，我们来做一些习题加深理解：

例一：

测试结果如图：

 

例一分析：

-1是整数：（补码）11111111111111111111111111111111

a:

把它放入char 类型的变量中发生截断

剩余11111111

以%d的形式打印a时，发生整形提升，因为是有符号char，高位补符号位后为，11111111111111111111111111111111，计算得原码10000000000000000000000000000001

打印-1。

b:

在VS编译环境中认为，char就是signedchar 因此把它放入signed char 类型的变量中，与a情况相同，故也打印-1

c:

把它放入unsigned char 类型的变量中发生截断，

剩余11111111

以%d的形式打印a时，发生整形提升，因为是无符号char，高位补0后为，

00000000000000000000000011111111，符号位为0，是正数，因此打印255

例二：

 测试结果如图：

 

例二分析：

-128是负整数

原码：10000000000000000000000010000000

反码：11111111111111111111111101111111

补码：11111111111111111111111110000000

   

-128放入char类型变量中，发生截断，变为：10000000

打印数据时发生整形提升，因为原来的类型是有符号的char 因此整形提升时高位补符号位1，为11111111111111111111111110000000，因为是以无符号整形（%u）的形式打印，因此它会认为读取到的是一个每一位都是有效位的数字，因此直接打印上述整形提升后结果的10进制形式，以下为计算器计算结果，与运行结果一致

 

例三：

 测试结果如图：

 

 

例三分析：

128是正整数

补码：00000000000000000000000010000000

128放入char类型变量中，发生截断，变为：10000000，接下来的分析和例二完全一样，不同的是char中只能存放数值范围为-128至127的整数，128补码阶段后10000000，最高位被认为是符号位，C语言中讲这个数规定为-128，因此你可以看到打印出的整数是-128.

 

例四：

测试结果如图

 

例四分析： 

-20补码：11111111111111111111111111101100

10补码：00000000000000000000000000001010

两个不同类型的数据计算时存在数据转换：

这里在相加时，int会被转化为unsigned int

i+j=11111111111111111111111111110110

%d是打印有符号整数，读取内存时，最高位为1，为负数，求其原码得

10000000000000000000000000001010,因此打印-10

例五：

测试结果如图：

 

例五分析： 前面i=9至i=0的判断肯定没有问题，但是当i=0打印出来后还要进行一步i-1,但结果是-1吗？显然不是，因为i是无符号整型，i>=0无论经过怎样的运算，其结果都会被解析为>=0,那么系统就将陷入死循环。为了方便观察，我们利用Sleep()函数把每一次执行的时间调久一点，使用时记得引用头文件windows.h。

为什么0完了是4294967295呢？计算机转换其2进制为11111111111111111111111111111111

是00000000000000000000000000000000-00000000000000000000000000000001计算所得，因为只存的下32个比特位，因此借位到32位为止。

例六：

 测试结果如图：

 

例六分析：计算数组a中存放的字符串长度，只要找到字符串的结束标志‘\0’即可，其ASCII码值是0，因此我们算第一个0出现之前字符数量即可，根据例三我们可知，char类型中只能放得下-128至127的整数，因此在，i=127之前，都按照常规运算存放数据即可，等到i=128,就要进行分析了：

-1二进制补码：11111111111111111111111111111111

128二进制补码：00000000000000000000000010000000

相减得11111111111111111111111101111111

发生截断，只留8位：01111111，故a[128]=127

继续往后算a[i]=-128时截止，此时i=255,当i=256时

-1补码：11111111111111111111111111111111

256补码：00000000000000000000000100000000

相减得11111111111111111111111011111111

其原码为10000000000000000000000100000000

发生截断，只留8位：00000000，故a[256]=0

它之前字符的长度即为所求，最终为255（其实就是-128至127除0外所有整数之和）

例七：

测试结果如图：

 

 例七分析：unsigned char所能表示的整数范围是0-255，因为没有符号位，所以都是有效位【00000000-11111111】，因此无论i怎么变换，最终都会被解析为这个范围内的数字，因此永远符合条件而成为死循环。

浮点型在内存中的存储

3.14159

1E10

浮点数家族包括： float 、 double 、 long double 类型。

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

接下来我们看一个例子：

显然，不同的结果告诉我们整数和浮点数在内存的存储方式和读取方式不同，接下来我们详细来看。

浮点数存储规则  

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

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

(-1)^S 表示符号位，当 S=0 ， V 为正数；当 S=1 ， V 为负数。

M 表示有效数字，大于等于 1 ，小于 2 。//因为是2进制，类比10进制

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、前面说过， 1≤M<2 ，也就是说， M 可以写成 1.xxxxxx 的形式，其中 xxxxxx 表示小数部分。IEEE 754规定，在计算机内部保存 M 时，默认这个数的第一位总是 1 ，因此可以被舍去，只保存后面的xxxxxx部分。比如保存 1.01 的时候，只保存01 ，等到读取的时候，再把第一位的 1 加上去。这样做的目的，是节省 1 位有效数字。以 32 位浮点数为例，留给M 只有 23 位，将第一位的1 舍去以后，等于可以保存 24 位有效数字。

2、

至于指数 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 。

3、然后，指数 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 ）；

到此，我们已经了解了浮点数存储和读取的规则，那接下来就可以 解释前面的题目：

下面，让我们回到一开始的问题：为什么 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 。

9.0 -> 1001.0 -> ( - 1 ) ^01 . 0012 ^3 -> s = 0 , M = 1.001 , E = 3 + 127 = 130

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

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

0 10000010 001 0000 0000 0000 0000 0000

这个 32 位的二进制数，还原成十进制，正是 1091567616 。

本节内容可能在真正的工作中很少用到，但学习这种基础性知识像是在修炼内功，这样在之后遇到一些问题的时候，我们不至于会一头雾水，这些知识给我们提供了其它解决问题的思路，因此也很重要。