数据在内存中的存储

本章重点：

• 数据类型详细介绍。
• 整形在内存中的存储：原码，反码，补码。
• 大小端字节序介绍及判断。
• 浮点型在内存中的存储解析

---

1.数据类型介绍

char           //字符数据类型

short         //短整形

int             //整形

float           //单精度浮点数

double       //双精度浮点数

long          //长整形

longlong    //更长的整形

//c语言有没有字符串类型？

---

整形的基本归类：

整形家族：

char 虽然是字符类型，但是字符类型存储的时候，存储的字符的ascii码值，ASCII值是整数

char:               //char c1 ：char到底是有符号还是无符号呢？  >>不确定，取决于编译器的实现。                     

unsigned char                 //无符号字符型

signed char                    //有符号字符型

int：                               //有符号整型

unsigned int                   //无符号整型

signed int                       //有符号整型

short:                               //short s1 : 有符号的 ， short  等价于  signed short

unsigned short [ int ]       //unsigned short s2 : 无符号的short

signed short     [ int ]       //signed short s3 ： 有符号的short

long:                                //long n = 0; long  等价于  signed long

unsigned long  [ int ]       //unsigned long n2 = 0；

signed long      [ int ]       //long signed n3 = 0;

---

浮点数家族：

float

double

---

构造类型：

> 数组类型

> 结构体类型      struct

> 枚举类型          enum

> 联合类型          union

 指针类型：

int* pi

char* pi

float* pf

void* pv

空类型：

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

---

2.整形在内存中的存储：

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

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

比如：

int a = 20

int b = -10

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

下来了解下面的概念：

原码，反码，补码 

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

原码：

• 直接将二进制按照正负数的形式翻译成二进制就可以。

反码：

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

补码：

• 反码+1就得到补码。

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

负数的原，反，补码要计算

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

为什么呢？

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

下面计算一道题 : 

int main()
{
    1-1;
return 0;
} 

 1-1 可以写成 ： 1+（-1）

1 和 -1 互相相加，因为整形在数据存放内存中存放的是补码形式，所以我我们先写出1和（-1）的补码，然后补码互相相加。

首先是1：1是正整数他的原码，反码，补码相同。所以：

00000000000000000000000000000001        补码

其次是（-1）：因为是负整数所以他的原，反，补码要计算。

这里我要插入一些概念：符号位

符号位就是最高位，也就是左边第一位，如果符号位是0，那么这是正正数，如果是1，那么这数是负数。

0  ——  正数

1  ——  负数

 (-1)的原码是 ：10000000000000000000000000000001         

符号位不变，其他位按位取反，得到反码。

          反码是 ：1111111111111111111111111111111111110

反码+1得到补码

          补码是 ：1111111111111111111111111111111111111

我们算到了1和（-1）的补码了，接下来是相加：

   00000000000000000000000000000001

   1111111111111111111111111111111111111

1 00000000000000000000000000000000 

最前面的1被溢出了，溢出的哪一位会被抹掉。结果全为0，得0。                                                           

所以1+（-1）= 0

再来一道题：

//输出什么？
#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;
}

a:  的原码：-1是有符号

原 ：10000000000000000000000000000001

反 ：1111111111111111111111111111111111110

补 ：1111111111111111111111111111111111111  

因为char 型是1个字节，是八个比特位，所以这里要出现截断，要低位，所以：

11111111     ：   a

b也是有符号char 型 ，他的补码也是跟上面一样 ：b  :    11111111 

原 ： 10000000000000000000000000000001

反 ： 1111111111111111111111111111111111110

补 ： 1111111111111111111111111111111111111   

同样这里发生截断，结果为 ：

11111111    :     c    等于  255

打印的时候，打印的是%d（无符号整形），所以会发生整型提升，这时候无符号char和有符号char的区别就在整型提升中体现出来了。

整型提升：

整型提升是按类型来提升，无符号整型提升要高位直接补0，有符号整型按照高位号（符号位）来补0，如果高位是0，高位就补0，如果高位是1，就高位补1

打印之前要发生整型提升。

a是有符号数整型提升如下：根据整型提升原则

1111 1111 1111 1111 1111 1111 1111 1111

同样b的也是：

1111 1111 1111 1111 1111 1111 1111 1111

c就不一样了，因为c是无符号数：

0000 0000 0000 0000 0000 0000 1111 1111

整型提升算是完了，接下来是要打印部分了，因为%打印，打印出来的是原码，我们接下来打印之前还得把这个补码换原码形式打印。

补码-1得反码，取反得原

根据上面得原则我把a，b，c 的原码直接写了。

a ：1000 0000 0000 0000 0000 0000 0000 0001

b ：1000 0000 0000 0000 0000 0000 0000 0001

c：  1111 1111 1111 1111 1111 1110 0000 0000

---

再看一道题：

int main()
{

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

i  是有符号整型 ：

原 ： 1000 0000 0000 0000 0000 0000 0001 0100>>-20

反 ： 1111 1111 1111 1111 1111 1111 1110 1011

补 ： 1111 1111 1111 1111 1111 1111 1110 1100

 j 是无符号整型 ： 

原，反，补相同

0000 0000 0000 0000 0000 0000 0000 1010

10和（-20）的补码相加：

i ： 1111111111111111111111111111       1100

j ： 00000000000000000000000000001010

等于 ：1111111111111111111111111110110       这是补码

打印要原码所以：

反 ： 11111111111111111111111111110101

原 ： 10000000000000000000000000001010        -10

---

再看一道题：

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

先找出a的原，反，补。

原 ： 10000000000000000000000010000000

反 ： 11111111111111111111111101111111

补 ： 11111111111111111111111110000000

因为char 类型是一个字节，八个比特位，这里存不下32位，所以这里会发生截断。截断保留低位。所以：

a的补码 ： 10000000

接下来是打印部分。%u是打印无符号整型的意思。32个比特位，所以要发生整型提升。

11111111111111111111111110000000。

---

3.大小端字节序介绍及判断。

大小端介绍：

什么是大端小端：

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

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

为什么有大小端呢：

为什么会有大小端模式之分呢？这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一 个字节，一个字节为8bit。但是在C语言中除了8bit的char之外，还有16bit的short型，32bit的long型（要看具 体的编译器），另外，对于位数大于8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字 节，那么必然存在着一个如果将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。 例如一个 16bit 的 short 型 x ，在内存中的地址为 0x0010 ， x 的值为 0x1122 ，那么 0x11 为高字节， 0x22 为低字节。对于大端模式，就将 0x11 放在低地址中，即 0x0010 中， 0x22 放在高地址中，即 0x0011 中。小 端模式，刚好相反。我们常用的 X86 结构是小端模式，而 KEIL C51 则为大端模式。很多的ARM，DSP都为小 端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。

大小端的判断：

int check_sys()
{
	int a = 18;
	return *(char*)&a;
}
int main()
{
	int ret = check_sys();
	if (ret = 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}

---

浮点型在内存中的存储解析：

常见的浮点数：

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^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。

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从内存中取出还可以再分成三种情况：

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）；

---

浮点数存储的例子：

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; 
} 

输出的结果是什么呢？

num 和 *pFloat 在内存中明明是同一个数，为什么浮点数和整数的解读结果会差别这么大？ 要理解这个结果，一定 要搞懂浮点数在计算机内部的表示方法。

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

 本章结束：