一、整数在内存中的存储

1.1、整数的存储方式

  
  我们知道，整形分为有符号整形和无符号整形。对于无符号整型来说，他所有位均为数值位；而有符号整形，他的最高位代表符号位，其余位为数值位，符号位用0表示正，1表示负。
  

注：$char$类型虽然是存储字符，但本质是存其ASCII值，因此也可以看作是整形。
注：有符号和无符号只针对整型，不包括浮点型等
  

在【C语言】——详原解操作符（上）中，我曾提到，整数在内存中的存储有三种方式：原码、反码、补码。下面，让我们简单回顾一下。

• 原码：直接将数值按他的正负数形式翻译成二进制得到的就是原码
• 反码：源码的符号位不变，数值位按位取反即为反码
• 补码：将反码加一，得到的就是补码

  在内存中，整数的存储和运算都是以补码的形式，只有显示给用户时，才是原码的形式。
  
为什么呢？

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

  
  

1.2、大小端字节序

（1）大小端字节序的定义

  不知大家在平时调试代码时，大家有没有发现一个奇怪的现象：整型在内存中好像是倒着存的。
  
如图：

  
  上图显示的是整型变量 $a$ 在内存中的存储情况，按我们的习惯不应该是：00 00 00 01 吗？为什么是 01 00 00 00 呢？
  
  上面这种存储方式叫小端字节序存储
  
  首先，我们来看看什么是大小端。
  
  在内存中，数据是以内存为单位进行存储的，那么，超过一个字节大小的数据的存储就不可避免的涉及到存储顺序问题，按照不同的存储顺序，我们分为大端字节序存储和小端字节序存储，下面是具体概念。

• 小端字节序存储：指数据的低位字节内容保存在内存中的低地址处，而数据的高字节内容保存在内存的高地址处。
• 大端字节序存储：指数据的高位字节内容保存在内存的低地址处，而数据的低字节内容保存在内存的高地址处。

  数据是大端还是小端存储并不由编译器决定，而是取决于硬件设备。
  
  
为什么会分大小端呢？

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

  
  

（2）判断大小端

  
  既然知道了计算机分为大端和小端存储，那有没有办法通过代码来判断自己的设备是大端还是小端呢？
  
  我们不妨这样想，往一个整形中存放数据，再想办法只读取他第一个字节内容，根据该字节存储的内容来判断是大端还是小端。

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

  
  我们来分析return (*(char*)&i);这句代码：

• 我们取出变量 $i$ 的地址，因为 $char$* 型指针只会访问一个字节的内容，所以将其强制类型转换成 $char$* 类型，再对其进行解引用。
• 同时我们还知道：一个变量的地址，是其所有字节的地址中，地址最小的字节的地址。因此解引用得到的是 $i$ 中最小字节地址所存储的内容，如果存储值为 1，则为小端存储，如果为 0，则为大端存储

  
  当然，，我们还可以用联合体来判断

int check_sys()
{
	union
	{
		int i;
		char c;
	}un;
	un.i = 1;
	return un.c;
}

  关于联合体的知识，我们放到后面去讲
  
  

1.3、整型练习

  
练习一：

#include<stdio.h>
int main()
{
	char a = -1;
	signed char b = -1;
	unsigned char c = -1;
	printf("a=%d, b=%d, c=%d\n", a, b, c);
	return 0;
}

  

• 首先我们来看char a = -1;：$char$ 类型是$（signed）char$ 还是$（unsignedchar）$ 取决于具体编译器的实现，但大部分是（signed）char。
• -1 的补码是 11111111 11111111 11111111 11111111（整数默认4个字节），因为 $char$ 只有一个字节大小，发生截断，$a$ 中放的是 11111111。同理char b=-1中 $b$ 中放的也是11111111。
• 接下来，我们来看unsigned char c = -1;：$c$ 中存放的也是 11111111，虽然 -1 是负数，但是存还是照样存的（先把数据存进去再说）
• 虽然 $abc$ 里存的都是 8 个 1 ，但以什么方式看待这 8 个 1 是不同的，对 $ab$ 来说，他们认为 8 个 1 是 -1，而对 $c$ 来说，他认为 8 个 1 是 255。
• 再来看最后一句，首先，我们要知道％d是以有符号整型来打印，打印 $abc$ 时，他们要先发生整形提升（详情请看【C语言】——详解操作符（下））。
• • 对 $ab$ 来说他们是有符号类型，整形提升按他们的符号位进行提升，即 11111111 11111111 11111111 11111111，补码转为源码，打印的结果是 -1。
• • 而对于 $c$ 来说他是无符号类型，整形提升高位补 0，即 00000000 00000000 00000000 11111111，因为首位是 0，被认为是正数，正数的原反补码相同，结果为 255。

答案：-1、-1、255

  
  

练习二：

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

  

我们先来看 $a$

• 首先，我们来看 -128 的原码 反码 补码
  原码：10000000 00000000 00000000 10000000
  反码：11111111 11111111 11111111 0111111
  补码：11111111 11111111 11111111 10000000
  $a$ 存储时，发生截断，存后面 8 个 $bit$ 位，即 10000000
• ％u是以无符号整型来打印数据，打印前，$a$ 先发生整形提升，因为 $char$ 为有符号类型，整型提升按符号位提升，即 11111111 11111111 11111111 1000000，而％u认为他是无符号数，因此打印的是一个很大的数。
• 同理，$b$ 也是类似的分析方法

答案：a=4294967168, b=4294967168
  
  
 
练习三：

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

  

让我们一起来分析这道题

• 数组 $a$ 中存放的是 $char$类型 的数据，通过 $for$ 循环，依次放入 -1，-2，-3 ······ 等数据，循环 1000 次。而因为 $a$ 中元素是 $char$类型，范围是 -128至127，因此放入的数据会周期循环。
• 而题目要求打印的是strlen(a)的值，我们知 $strlen$函数 是计算字符串的长度，遇到 ‘\0’ 停止计算，而 ‘\0’ 的本质是 0，因此这题的核心思路就是：计算第一次放入0，是第几个数放入，再减去一，即可知道前面翻入几个数，即字符串长度。

  

 
 

答案：255
  
  
练习四：

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

  

  该代码会打印多少个 $"helloworld"$ 呢？是 $256$ 个吗？
  答案是：死循环
  因为 $i$ 是 $unsignedchar$ 类型，他的数据范围是 0-255，当值为 255 即 11111111 时，加 1 为 100000000，因为只能存 8 比特位，发生截断，即 00000000，再不断加一，如此往复，永远跳不出循环。

  

 
 

  

#include<stdio.h>
int main()
{
	unsigned int i;
	for (i = 9; i >= 0; i--)
	{
		printf("%u\n", i);
	}
	return 0;
}

同理，这段代码也是如此，一样是死循环

  
  
练习五：

#include<stdio.h>
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);
	return 0;
}

  

• 首先我们来看 $ptr1$：&$a$ 取出的是整个数组的地址，+1 则是跳过了整个数组，之后将该地址强制类型转换成 $int$ * 类型。％x 是以十六进制的方式打印数据，$ptr1[-1]$ 等价于 *$（ptr-1）$，由于 $ptr1$ 是整型指针，-1 后退 4 个字节指向元素 4
   
  图示：
   
  
   

  

• 接着我们来看 $ptr2$，首先 $a$ 是数组首元素的地址，取出后将其强制类型转换成整型变量，后面 +1，即数学上的+1，指针向后移动一位。
• 再将该整数强制类型转换成整型指针，最后，以十六进制打印 $ptr2$ 解引用的值，因为强转成 $int$* 指针，所以访问权限为 4 个字节。
   
  
   
• 因为为小端存储，所以取出的数实际为 02 00 00 00

答案：4  2000000

  
  

二、浮点数在内存中的存储

2.1、引言

  像 3.14159、1E10 等数被称为浮点数。

  首先我来问问大家，浮点数为什么叫浮点数呢？

  我们来看个例子：$123.45$ = $12.345\ast 10^1$ = $1.2345\ast 10^2$

  可以看到，该数的小数点是可以左右浮动的，因此被称为浮点数。
 
  浮点数家族包括 $float$、$double$、$longdouble$ 等类型，浮点数的表示范围，在 <float.h>中定义
  
  
接下来，让我们看一道习题，开启接下来的浮点数学习之旅。

#include<stdio.h>

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

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

  
输出结果：

  为什么会这样呢？按我们之前的知识，四个答案应该是：9、9.0、9、9.0 。但现在，只有两个正确，为什么呢？
  

我们先粗略分析一下原因

• 我们以整型形式放，以浮点型形式取出，有问题
• 我们以浮点型的形式放，以整型的形式取出，也有问题

  我们不妨做一个大胆的猜测：整型和浮点型在内存中的存储有很大差异。
  
  那到底是不是这样呢？我们一起来学习浮点型在内存中的存储。
  

2.2、浮点数的存储规则

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

 
举例来说：

十进制的 $5.0$，用二进制表示是 $101.0$，可写成 $1.01\ast 2^2$。 那么，按上面 V 的形式，他的 S=0、 M=1.01、 E=2
 
十进制的 $-5.0$，用二进制表示是 $-101.0$，可写成 $-1.01\ast 2^2$ 那么，按上面 V 的形式，它的 S=1、 M=1.01、 E=2

  
IEEE 754 规定：
  
  对于 32 位（$float$） 的浮点数，最高的一位存储的是符号位 S，接着 8 位存储指数位 E，剩下的 23 位存储有效数字 M

  
  而对于 64 位（$double$） 的浮点数，最高的一位存储的是符号位S，接着11位存储指数位E，剩下的52位存储有效数字M

  

2.3、浮点数的存储过程

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

  我们前面说过，M 的取值 $1<=M<2$ ，也就是写成 $1.xxxxx$ 的形式，其中 xxxxx 是小数部分。IEEE 754 中规定，计算机那边存储 M 时，默认这个数的第一位总是 1 ，因此1可以被舍去，只保留后面的小数部分，比如保存 1.01 时，只存储 01。等到读取的时候，再把第一位的 1 加上去。这样做的目的是可以节省一位有效数字的空间

 
  至于指数E，则更为复杂一些：

  首先，规定 E 是一个无符号整数。这样，如果 E 为 8 位，他的存储范围是 0～255 ，如果 E 为 11 位，他的存储范围则是 0～2047。但是，我们知道，指数位是可以有负数的，所以 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 的二进制形式为 0.1，由于规定整数部分必须为 1，即小数点右移1位，为 $1.0\ast 2^{-1}$ ，其阶码(E) 为 -1+127(中间值) = 126，表示为 01111110，而尾数 1.0去掉整数部分为 0，补齐 0 到 23 位
   0 01111110 00000000000000000000000
     
2. E全为0
     这时，浮点数的指数E等于1-127（或者1-1023）即为真实值，有效数字M不再加上第一位的1，而是还原为0.xxxxx的小数。这样做是为了表示 ±0，以及接近于 0 的很小的数字
   0 00000000 00100000000000000000000
     
3. E全为1
     这时，如果有效数字 M 全为 0，表示 ± 无穷大（正负取决于符号位S）
   0 11111111 00010000000000000000000

  
  

2.4、题目解析

  
  现在，让我们回到一开始的题目
  
先来看第一个环节：

• int n = 9;：我们以整型的形式存储 9，此时9在内存中表示为：
  00000000 00000000 00000000 00001001
• printf("n的值为：%d\n", n);：这句代码以整型的形式打印，打印出 9，没有问题
• printf("*pFloat的值为：%f\n", *pFloat);：这句代码以浮点型的形式打印
• 在 *$pFloat$ 眼里，它指向的数据是这样的：
  0 00000000 00000000000000000001001
  即S = 0， E = 0， M = 1001
  由于指数为 0 符合 E 为全 0 的情况。因此浮点数 V 写成：
  V = $(-1{)}^0$ $\ast$ 0.00000000000000000001001 $\ast$ $2^{-126}$ = 1.001 $\ast$ $2^{-146}$
• 显然，V是一个很小且非常接近 0 的数，用十进制小数表示就是 0.000000

  
再看第二个环节：
  
放进浮点数 9.0

• 首先 9.0 用二进制表示 1001.0，换算成科学技术法是：$1.001\ast 2^{-3}$。所以 $9.0$ = $(-1{)}^0\ast (1.001)\ast 2^3$
• 即S = 0，E = 3 + 127 = 130，M = 001 后面补 20 个 0
• $9.0$ 在内存中的存储为：
  0 10000010 00100000000000000000000
• 这个 32 位数。以整数的形式取出，就是整数在内存中的补码，因为为正数，原反补三码相同，十进制表示，正是1091567616

  
  
  
  

---

  好啦，本期关于数据在内存中的存储就介绍到这里啦，希望本期博客能对你有所帮助。同时，如果有错误的地方请多多指正，让我们在C语言的学习路上一起进步！