很楠不爱3

这个屌丝很懒，什么也没留下！

热门标签

【C语言】——数据在内存中的存储

作者：很楠不爱3 | 2024-05-01 17:09:31

踩

【C语言】——数据在内存中的存储

一、整数在内存中的存储

1.1、整数的存储方式

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

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

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

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

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

为什么呢？

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

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

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

1.2、大小端字节序

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

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

如图：

上图显示的是整型变量 $a$ 在内存中的存储情况，按我们的习惯不应该是：00 00 00 01 吗？为什么是 01 00 00 00 呢？

上面这种存储方式叫小端字节序存储

首先，我们来看看什么是大小端。

在内存中，数据是以内存为单位进行存储的，那么，超过一个字节大小的数据的存储就不可避免的涉及到存储顺序问题，按照不同的存储顺序，我们分为大端字节序存储和小端字节序存储，下面是具体概念。

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

数据是大端还是小端存储并不由编译器决定，而是取决于硬件设备。

为什么会分大小端呢？

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

例如：一个 16 $bi t$ 的 $s h or t$ 类型 $x$ ，在内存中的地址为 $0 x 0010$ ， $x$ 的值为 $0 x 1122$ ，那么 $0 x 11$ 为高字节， $0 x 22$ 为低字节。对于大端模式，就将 $0 x 11$ 放在低地址中，即 $0 x 0010$ 中， $022$ 放在高地址中，即放在 $0 x 0011$ 中。而小端模式，刚好相反。

我们常用的 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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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

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

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

int check_sys()
{
	union
	{
		int i;
		char c;
	}un;
	un.i = 1;
	return un.c;
}
1
2
3
4
5
6
7
8
9
10

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

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;
}
1
2
3
4
5
6
7
8
9

首先我们来看char a = -1;： $c ha r$ 类型是 $（ s i g n e d ） c ha r$ 还是 $（ u n s i g n e d c ha r ）$ 取决于具体编译器的实现，但大部分是（signed）char。
-1 的补码是 11111111 11111111 11111111 11111111（整数默认4个字节），因为 $c ha r$ 只有一个字节大小，发生截断， $a$ 中放的是 11111111。同理char b=-1中 $b$ 中放的也是11111111。
接下来，我们来看unsigned char c = -1;： $c$ 中存放的也是 11111111，虽然 -1 是负数，但是存还是照样存的（先把数据存进去再说）
虽然 $ab c$ 里存的都是 8 个 1 ，但以什么方式看待这 8 个 1 是不同的，对 $ab$ 来说，他们认为 8 个 1 是 -1，而对 $c$ 来说，他认为 8 个 1 是 255。
再来看最后一句，首先，我们要知道％d是以有符号整型来打印，打印 $ab c$ 时，他们要先发生整形提升（详情请看【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;
}
1
2
3
4
5
6
7
8

我们先来看 $a$

首先，我们来看 -128 的原码反码补码
原码：10000000 00000000 00000000 10000000
反码：11111111 11111111 11111111 0111111
补码：11111111 11111111 11111111 10000000
$a$ 存储时，发生截断，存后面 8 个 $bi t$ 位，即 10000000
％u是以无符号整型来打印数据，打印前， $a$ 先发生整形提升，因为 $c ha r$ 为有符号类型，整型提升按符号位提升，即 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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

让我们一起来分析这道题

数组 $a$ 中存放的是 $c ha r$ 类型的数据，通过 $f or$ 循环，依次放入 -1，-2，-3 ······ 等数据，循环 1000 次。而因为 $a$ 中元素是 $c ha r$ 类型，范围是 -128至127，因此放入的数据会周期循环。
而题目要求打印的是strlen(a)的值，我们知 $s t r l e n$ 函数是计算字符串的长度，遇到 ‘\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;
}
1
2
3
4
5
6
7
8
9
10

该代码会打印多少个 $" h e ll o w or l d "$ 呢？是 $256$ 个吗？
答案是：死循环
因为 $i$ 是 $u n s i g n e d c ha r$ 类型，他的数据范围是 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;
}
1
2
3
4
5
6
7
8
9
10

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

练习五：

#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;
}
1
2
3
4
5
6
7
8
9

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

图示：

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

因为为小端存储，所以取出的数实际为 02 00 00 00

答案：4 2000000

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

2.1、引言

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

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

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

可以看到，该数的小数点是可以左右浮动的，因此被称为浮点数。

浮点数家族包括 $f l o a t$ 、 $d o u b l e$ 、 $l o n g d o u b l e$ 等类型，浮点数的表示范围，在 <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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出结果：

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

我们先粗略分析一下原因

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

我们不妨做一个大胆的猜测：整型和浮点型在内存中的存储有很大差异。

那到底是不是这样呢？我们一起来学习浮点型在内存中的存储。

2.2、浮点数的存储规则

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

举例来说：

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

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

IEEE 754 规定：

对于 32 位（ $f l o a t$ ）的浮点数，最高的一位存储的是符号位 S，接着 8 位存储指数位 E，剩下的 23 位存储有效数字 M

而对于 64 位（ $d o u b l e$ ）的浮点数，最高的一位存储的是符号位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从内存中取出还可以再分成三种情况

E不全为 0 或不全为 1
这时，浮点数就采用下面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将有效数字M前加上第一位的1.
比如：0.5 的二进制形式为 0.1，由于规定整数部分必须为 1，即小数点右移1位，为 $1.0*2^{-1}$ ，其阶码(E) 为 -1+127(中间值) = 126，表示为 01111110，而尾数 1.0去掉整数部分为 0，补齐 0 到 23 位
0 01111110 00000000000000000000000
E全为0
这时，浮点数的指数E等于1-127（或者1-1023）即为真实值，有效数字M不再加上第一位的1，而是还原为0.xxxxx的小数。这样做是为了表示 ±0，以及接近于 0 的很小的数字
0 00000000 00100000000000000000000
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);：这句代码以浮点型的形式打印
在 * $pFl o a t$ 眼里，它指向的数据是这样的：
0 00000000 00000000000000000001001
即S = 0， E = 0， M = 1001
由于指数为 0 符合 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$ = $1)^0 * (1.001)*2^3$
即S = 0，E = 3 + 127 = 130，M = 001 后面补 20 个 0
$9.0$ 在内存中的存储为：
0 10000010 00100000000000000000000
这个 32 位数。以整数的形式取出，就是整数在内存中的补码，因为为正数，原反补三码相同，十进制表示，正是1091567616

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/519862