数据的存储-C语言进阶

_Amor_

已于 2023-11-12 16:37:30 修改

阅读量64

点赞数

分类专栏： C语言文章标签： c语言开发语言

于 2023-10-17 11:22:31 首次发布

本文链接：https://blog.csdn.net/ma123456542/article/details/133878202

版权

C语言专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1. 数据类型的介绍

前面我们已经学习力基本的内置类型：

char         //字符
short        //短整型
int          //整型
long         //长整型
long long    //更长的整型
float        //单精度浮点数
double       //双精度浮点数

以及它们所占存储空间的大小。

在C语言标准中：sizeof(long) >= sizeof(int))（32位平台下是 4 个字节，64位平台下是 8 个字节）

类型的意义：

使用这个类型开辟内存空间的大小（大小决定了使用范围）。
如何看待内存空间的视角。

1.1 类型的基本归类：

整形家族：

作用：整型变量表示的是整数类型的数据。区别在于所占内存空间不同。

char
	char
	unsigned char ---------------- 0 ~ 255
	signed char ------------------ -128 ~ 127
short
	unsigned short [int] --------- 0 ~ 65535
	signed short [int] ----------- -32768 ~ 32767
int
	unsigned int
	signed int
long
	unsigned long [int]
	signed long [int]
long long
	unsigned long long [int]
	signed long long [int]

字符的本质是 ASCII 码值，是整型，所以划分到整形家族。

在C语言中，int a; —> signed int a;
而 char 到底是 signed char 还是 unsigned char，C标准是未定义的，取决于编译器（大部分编译器中 char 按照 signed char 来处理的）。

浮点数家族：

作用：用于表示小数

float	//单精度浮点数
double	//双精度浮点数
long double(C99标准)

两者的区别在于表示的有效数字范围不同：

float 精度低，存储的数据范围较小，有效数字范围为 7 位有效数字。
double 精度高，存储的数据范围更大，有效数字范围为 15~16 位有效数字。

构造类型（自定义类型）：
我们可以自己创建出新的类型。

> 数组类型 int [5]
> 结构体类型 struct
> 枚举类型 enum
> 联合类型 union

指针类型：

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

空类型：

void 表示空类型（无类型）：通过应用于函数的返回类型、函数的参数、指针类型。

用于函数的返回类型：表示函数不会返回值。
用于函数参数：表示函数不需要传任何参数。（⚠）
用于指针类型。

2. 整型在内存中的存储

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

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

比如：

int a = 20;
int b = -10;

我们知道为 a 分配 4 个字节的空间。
那如何存储？先了解下面的概念：

2.1 原码、反码、补码

计算机中整数有三种 2 进制表示方式，即原码、反码和补码。

数字有不同的表现形式：

二进制：0b10101
八进制：025
十进制：21
十六进制：0x15

三种表示方法均有 符号位 和 数值位 两部分：

符号位都是 0 表示 “正”，1 表示 “负”。
数值位：
- 正数的原、反、补码都相同。
- 负数的原、反、补码是需要计算的。

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

计算方法：
反码：将原码的符号位不变，其他位依次按位取反就可以得到反码。
补码：反码 +1 就得到补码。

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

为什么呢？

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

使用补码，可以将符号位和数值域统一处理；
同时，加法和减法也可以统一处理（CPU只有加法器）。
此外，补码和原码相互转换，其运算过程是相同的（均为除符号位取反 + 1），不需要额外的硬件电路。

2.2 大小端介绍

什么叫大端小端：

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

为什么有大端和小端：

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

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

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

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

2.3 练习

1.
//输出什么？
#include <stdio.h>

int main() {
	char a = -1;//数据截断
	signed char b =  -1;
	unsigned char c = -1;
	printf("a=%d,b=%d,c=%d", a, b, c);//整型提升:根据 a b c 变量的类型进行
	
	return 0;
}
// -1 -1 255

2.
//输出什么？
#include <stdio.h>

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

3.
//输出什么？
#include <stdio.h>

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

4.
//输出什么？
#include <stdio.h>

int main() {
	int i = -20;
	unsigned int j = 10;
	printf("%d\n", i + j);//以补码的形式进行运算
	
	return 0;
}
//-10

数据在内存中以补码的形式进行运算

5.
//输出什么？
#include <stdio.h>

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

6.
//输出什么？
#include <stdio.h>

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

strlen() 函数求字符串的长度，关注的是字符串中 ‘\0’(数字 0) 之前出现了多少字符。

7.
//输出什么？
#include <stdio.h>

unsigned char i = 0;
int main() {
	for (i = 0; i <= 255; i++) {
		printf("hello world\n");
	}
	return 0;
}
//死循环

8.
//输出什么？
#include <stdio.h>
#include <string.h>
int main() {
	if (strlen("abc") - strlen("abcdef") >= 0) {
		printf(">\n");
	}
	else {
		printf("<\n");
	}
	return 0;
}
//>

strlen() 函数返回无符号的整型。

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

常见的浮点数：

3.14159
2E3 / 2e3 = 2 * 10³ //科学计数法
浮点数家族包括：float、double、long double 类型。
浮点数表示的范围：float.h 中定义。（整形家族在 limits.h 中定义）

3.1 一个例子

浮点数存储的例子：

#include <stdio.h>

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

	return 0;
}

3.2 浮点数的存储规则

num 和 *pf 在内存中明明是同一个数，为什么浮点数和整数的解读结果会差别这么大？

要理解这个结果，一定要搞懂浮点数在计算机内部的表示方法。详细解读：

根据国家标准 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² 。那么，按照上面 V 的格式，可以得出 S = 0，M = 1.01，E = 2 。
十进制的 -5.0，写成二进制是 -101.0，相当于 -1.01 * 2² 。那么，按照上面 V 的格式，可以得出 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.xxxx 的形式，其中 xxxx 表示小数部分。

IEEE 754 规定，在计算机内部保存 M 时，默认这个数的第一位总是 1，因此可以被舍去，只保存后面的 xxxx 部分。

比如保存 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=117，即 0111 0101。

#include <stdio.h>
int main() {
	float f = 5.5;
	//5.5
	//101.1
	//1.011*2^2
	//s=0 m=1.011 e=2
	//0100 0000 1011 0000 0000 0000 0000 0000
	//0x40b00000

然后，指数 E 从内存中取出还可以再分成三种情况：
E 不全为 0 或不全为 1

这时，浮点数就采用下面的规则表示，即指数 E 的计算值减去 127（或 1023），得到真实值，再将有效数字 M 前加上第一位的 1。
比如：
0.5（1/2）的二进制形式为 0.1，由于规定正数部分必须为 1，即将小数点右移 1 位，则为 1.0*2^-1 ，其阶码为 -1+127=126，表示为 0111 1110，而尾数 1.0 去掉整数部分为 0，补齐 0 到 23 位的 0，则其二进制表示形式为：
0 01111110 00000000000000000000000

E 全为 0

这时，浮点数的指数 E 等于 1-127（或者 1-1023）即为真实值，有效数字 M 不再加上第一位的 1，而是还原为 0.xxxx 的小数。这样做是为了表示 ±0，以及接近于 0 的很小的数字。

E 全为 1

这时，如果有效数字 M 全为 0，表示 ±无穷大（正负取决于符号位s）；

好了，关于浮点数的表示规则，就说到这里。

解释前面的题目（3.1 的例子）：

下面，让我们回到一开始的问题：为什么 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.00000000000000000001001 × 2^-126 = 1.001 × 2^-146
显然，V 是一个很小的接近于 0 的正数，所以用十进制小数表示就是 0.000000。

再看例题第二部分。
首先，浮点数 9.0 等于二进制 1001.0，即 1.001 × 2³ 。
9.0 -> 1001.0 -> (-1)^0×1.001×2^3 -> s=0, M=1.001, E=3+127=130
所以，写成二进制的形式，即
0 1000 0010 001 0000 0000 0000 0000 0000
这个 32 位的二进制数，还原成十进制，正是 1091567616。

本章完。