【C语言】数据的存储 -- 数据类型介绍 -- 存储 -- 浮点型在内存中的存储，很详细也很重要，不明白的一定要看

我不是女神ヾ 2023-09-27 17:14 64阅读 0赞

**目录**

1、数据类型介绍

1.1 类型的基本归类

2、整型在内存中的存储

2.1 原码、反码、补码

2.2 大小端介绍

2.3 练习

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

3.1 举一个例子

3.2 浮点数存储规则

--------------------

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*正文开始\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

## 1、数据类型介绍 ##

前面我们已经学习了基本的内置类型（C语言已经有的类型叫做内置类型）

> char short int long long long float double

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

**类型的意义：**

1.使用这个类型开辟内存空间的大小（大小决定了适用范围）。

2.如何看待内存空间的视角。

### 1.1 类型的基本归类 ###

**整型家族：**

char
    	unsigned char
    	signed char//char = signed char 是取决于编译器的
    short
    	unsigned short [int]//这里的int可以不写，下面一致	
    	signed short[int]//short = signed short ，signed 可省略
    int 
    	unsigned int 
    	signed int //int = signed int ，signed 可省略
    long
    	unsigned long [int]
    	signed long [int]//long = signed long ，signed 可省略

**注：**

**1.字符存储和表示的时候本质上使用的是ASCII码值，ASCII码值是整数，因此字符类型也归类到整型家族；**

**2.数值在分类的时候有正有负，因次就存在 unsigned（无符号，只有正），signed （有符号，可正可负），平时写的 int = signed int，signed可省略 。但是 char == signed char 是取决于编译器的（见到的编译器上大多是等于的）。**

**浮点型家族：**

float
    double

**构造类型（自定义类型）：**

>数组类型  //int arr[5],char str[10]
    >结构体类型 struct
    >枚举类型 enum
    >联合类型 union

**指针类型：**

int *pi;//+-1跳过几个字节看指针的类型，解引用访问几个字节也是看指针类型
    char *pc;
    float *pf;
    void *pv;

**空类型：**

void 表示空类型（无类型）

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

函数不希望有任何返回值就用 void ；函数的参数写成 void 代表了这个函数不需要参数；void\* p 是无具体类型的指针。

## 2、整型在内存中的存储 ##

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

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

**比如：**

int a = 20;
    int b = -10;

我们知道为 a 分配四个字节的空间。

那如何存储？

下来了解下面的概念：

### 2.1 原码、反码、补码 ###

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

三种表示方法均有**符号位**和**数值位**两部分，符号位都是用‘0’表示“正“，用‘1’表示”负“，而数值位只要把这个数字表示清楚就可以。

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

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

**举例：**

int main()
    {
    	int a = 20;
    	//原码：00000000 00000000 00000000 00010100
    	//反码：00000000 00000000 00000000 00010100
    	//补码：00000000 00000000 00000000 00010100
    	int b = -10;
    	//原码：10000000 00000000 00000000 00001010
    	//反码：11111111 11111111 11111111 11110101
    	//补码：11111111 11111111 11111111 11110110
    	return 0;
    }

![d2483782f1c2cf430ff3f60223e3402b.png][]

原码

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

反码

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

补码

反码+1就得到补码。

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

**我们为了更加清楚，使用调试可以观察一下内存中如何存储：**

**正数的原反补码相同说明不了问题，我们来看负数的**

![7b637001081aa6d9b10cf5d5ff511940.png][]

**这里是为了方便展示所以用的 16进制，在内存中就是以 2进制存储的。2进制数转换为 16进制数就是 ff ff ff f6。**

**Q：为什么数据存放内存中其实存放的是补码呢？**

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

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

**这段话有点难理解，我们举例来说明一下：**

**我们以 1 - 1 来说。上面的话说 CPU 只有加法器，而我们这里却是用减法处理的，因此我们改写为 1+(-1)，而CPU就是这样来做的。**

int main()
    {
    	1 + 1;
    	1 + (-1);
    	//1的补码： 00000000 00000000 00000000 00000001
    	//-1的原码：10000000 00000000 00000000 00000001
    	//-1的反码：11111111 11111111 11111111 11111110
    	//-1的补码：11111111 11111111 11111111 11111111
    	//1+(-1)补码相加：1 00000000 00000000 00000000 00000000
    	return 0;
    }

**分析：**

![0dd66a778aed2a1713838698d7b2617b.png][]

![59cf5ee33b51d3d8afe45ba989fd188f.png][]

**这也说明了内存中存储的是补码。**

### 2.2 大小端介绍 ###

**什么是大端小端：**

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

**讲简单点：**

![ac4678eec3517895a0c51cc31dd843df.png][]

**为什么有大端和小端：**

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

我们可以想到，超过了一个字节序就会出现排放顺序的问题。

![ec91d0f5077e0e2751ba8d8eca545765.png][]

如果我们从内存中拿出来这个数字乱序肯定是不行的，因此就只剩下正着存和反着存。

**因此就定义了****大端字节序存储，小端字节序存储。**

![650d1c312044773955889f68c13ff04a.png][]

**我们再进到 vs 编译器中看是如何存储的**

![33f325e9e4f99cf70263650f2c9a6226.png][]

### 2.3 练习 ###

**i>写出一个检测大小端的函数**

//如果是大端返回0
    //如果是小端返回1
    #include <stdio.h>
    int check_sys()
    {
    	int a = 1;
    	return *(char*)&a;
    }
    int main()
    {
    	if (1 == check_sys())
    		printf("小端\n");
    	else
    		printf("大端\n");
    	return 0;
    }

![bd79664c7f92e3abe84b8080d66b01e3.png][]

**分析：**

![36c2d247b3b530093a9497b94b0de475.png][]

**int 类型是4个字节，要取出1个字节我们对 a 的地址强转为 char\* 再解引用，这样取出的数字不是 1 就是 0 。**

**ii>看这段代码给出结果**

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

效果展示：

![5470b3ba2370eac50abeeb4f3aa92f03.png][]

**注：%d打印的是十进制的有符号数，%u打印的是十进制的无符号数。**

**如果（unsigned）char 类型变量赋值为负数，再用 %u 打印，是把负数整型提升后的补码当作原码解读后来打印。**

**Q：为什么是这样的值呢？**

**分析：**

![ae801248ff4478805abd126e7f18bba9.png][]

**这里的 signed char b 和 char a 是一样的。**

![60e27d6af889cbfda87be7b81d178e47.png][]

**引申：**

**char 的取值范围：**

![8715627346e008a7fafdf4203805f59e.png][]

**char 的取值范围是一个环状的，取出的值只会在这个范围里。**

**iii> 看这段代码给出结果**

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

效果展示：

![fc890e9c6d678ddd3212ae70d4116029.png][]

**Q：这是为什么呢？**

A：如果（unsigned）char 类型变量赋值为负数，再用 %u 打印，是把负数整型提升后的补码当作原码解读后来打印。

**iv>** **看这段代码给出结果**

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

效果展示：

![732ec2ea8f2f593e9b78eb86b9ef6d9f.png][]

**因为 %d 打印的是有符号数。**

**v> 看这段代码给出结果**

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

效果展示：

![004d6ea5f822bdd25626cac3f43ec140.png][]

**分析：**

**这段代码会死循环。**

![0b22044fd5e8b200a193d054acb11385.png][]

**vi> 看这段代码给出结果**

#include <stdio.h>
    #include <string.h>
    int main()
    {
    	char a[1000];
    	int i = 0;
    	for (i = 0; i < 1000; i++)
    	{
    		a[i] = -1 - i;
    	}
    	printf("%d", strlen(a));
    	return 0;
    }

效果展示：

![3c96bb5aa369583165b12b23b66ca953.png][]

**分析：**

![907b4811ea1121e89ded8934d10371a2.png][]

**二进制不断 +1/-1 是在这个圆上不断轮回。**

![31b8088b3a2567d69d435a2242d21dcb.png][]

**vii>** **看这段代码给出结果**

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

效果展示：

![1334315f2c2564e9dc405a1c153a2c5d.png][]

**分析：**

**光标一直在闪烁，说明代码是死循环的。unsigned char 的取值范围是 0 ~ 255的，i<=255的条件是恒成立的，因为i++不断执行都是在轮回。**

![a5ddcc31554fb44046b4d895a0cdb121.png][]

## 3、浮点型在内存中的存储 ##

**常见的浮点数：**

> 3.14159
> 
> 1E10（1.0\*10^10）
> 
> 浮点数家族包括：float、double、long double类型。
> 
> 浮点数表示的范围：float.h中定义。

### 3.1 举一个例子 ###

**浮点数存储的例子：**

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

效果展示：

![f563eee2c58a1ea78e8ed9e1a5c220ab.png][]

**Q：这是为什么呢？**

**A：**我们继续往下看，先看后面，再回头理解这个代码。

### 3.2 浮点数存储规则 ###

**要理解上面这个结果，一定要搞懂浮点数在计算机内部的表示方法。**

**详细解读：**

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

**很重要**

> **(-1)^S\*M\*2^E**
> 
> **(-1)^S表示符号位，当S=0，V为正数；当S=1，V为负数。**
> 
> **M表示有效数字，大于等于1，小于2。**
> 
> **2^E表示指数位**。

举例来说：

十进制的5.5，写成二进制是101.1，相当于1.011\*2^2。

那么，按照上面 V 的格式，可以得出 S=0 ，M = 1.011，E=2。

十进制的 -5.5，写成二进制是 -101.1，相当于 -1.011\*2^2。那么，S=1，M=1.011，E=2。

![e69c42223ee7e90277412f4be20d64e8.png][]

**IEEE 754规定：**

**对于 32 位的浮点数，最高的 1 位是符号位S，接着的 8 位是指数E，剩下的 23 位为有效数字M。**

![51b9836ffe20e8134ef64d88b8f3e6ef.png][]

**对于 64 位的浮点数，最高的 1 位是符号位S，接着的 11 位是指数E，剩下的 52 位为有效数字M。**

![51d8286346712802dedf650a50f56fa4.png][]

**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 位有效数字。

**因为M都是1.XXX的形式，这个1就可以省略掉，所以只存XXXX的形式，这样M就可以多存1位有效数字，这样就可以提高精准度。**

**至于指数 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的存储要加上中间值（float类型+127，double类型+1023）。**

**然后，指数 E 从内存中取出还可以再分成三种情况：**

**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

**E 全为 0**

> 这时，浮点数的指数 E 等于 1-127 （或者 1-1023 ）即为真实值， 有效数字M 不再加上第一位的 1 ，而是还原为 0.xxxxxx 的小数。这样做是为了表示 ±0 ，以及接近于 0的很小的数字。
> 
> V = (-1/1) \* 0.xxx \* 2^(1-127) 是一个很小的数字，无限接近于 0。

**E 全为 1**

> 这时，如果有效数字 M 全为 0，表示 +- 无穷大（正负取决于符号位 S）;
> 
> 同理，这将是一个很大的数字。

**我们现在再回头去分析举例的代码：**

![5e24da8c9aa39442dca2abb30a82bec7.png][]

**第一步：**

![b3b90f1a04ff7ee3193dfb1598d66815.png][]

**第二步：**

![b0c996598468461896ff258da1b48c84.png][]

**第三步：**

![3f908608bf88fa33ea2f40c722958d9b.png][]

**第四步：**

![f4f405d332c6eba0f2f736ddeda08ede.png][]

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*本章结束\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

由于本人能力有限，如果有大牛发现哪里有误请一定指出来。

如果大家看了有收获的话，点赞收藏加关注走一波，谢谢大家。

[d2483782f1c2cf430ff3f60223e3402b.png]: https://img-blog.csdnimg.cn/img_convert/d2483782f1c2cf430ff3f60223e3402b.png
[7b637001081aa6d9b10cf5d5ff511940.png]: https://img-blog.csdnimg.cn/img_convert/7b637001081aa6d9b10cf5d5ff511940.png
[0dd66a778aed2a1713838698d7b2617b.png]: https://img-blog.csdnimg.cn/img_convert/0dd66a778aed2a1713838698d7b2617b.png
[59cf5ee33b51d3d8afe45ba989fd188f.png]: https://img-blog.csdnimg.cn/img_convert/59cf5ee33b51d3d8afe45ba989fd188f.png
[ac4678eec3517895a0c51cc31dd843df.png]: https://img-blog.csdnimg.cn/img_convert/ac4678eec3517895a0c51cc31dd843df.png
[ec91d0f5077e0e2751ba8d8eca545765.png]: https://img-blog.csdnimg.cn/img_convert/ec91d0f5077e0e2751ba8d8eca545765.png
[650d1c312044773955889f68c13ff04a.png]: https://img-blog.csdnimg.cn/img_convert/650d1c312044773955889f68c13ff04a.png
[33f325e9e4f99cf70263650f2c9a6226.png]: https://img-blog.csdnimg.cn/img_convert/33f325e9e4f99cf70263650f2c9a6226.png
[bd79664c7f92e3abe84b8080d66b01e3.png]: https://img-blog.csdnimg.cn/img_convert/bd79664c7f92e3abe84b8080d66b01e3.png
[36c2d247b3b530093a9497b94b0de475.png]: https://img-blog.csdnimg.cn/img_convert/36c2d247b3b530093a9497b94b0de475.png
[5470b3ba2370eac50abeeb4f3aa92f03.png]: https://img-blog.csdnimg.cn/img_convert/5470b3ba2370eac50abeeb4f3aa92f03.png
[ae801248ff4478805abd126e7f18bba9.png]: https://img-blog.csdnimg.cn/img_convert/ae801248ff4478805abd126e7f18bba9.png
[60e27d6af889cbfda87be7b81d178e47.png]: https://img-blog.csdnimg.cn/img_convert/60e27d6af889cbfda87be7b81d178e47.png
[8715627346e008a7fafdf4203805f59e.png]: https://img-blog.csdnimg.cn/img_convert/8715627346e008a7fafdf4203805f59e.png
[fc890e9c6d678ddd3212ae70d4116029.png]: https://img-blog.csdnimg.cn/img_convert/fc890e9c6d678ddd3212ae70d4116029.png
[732ec2ea8f2f593e9b78eb86b9ef6d9f.png]: https://img-blog.csdnimg.cn/img_convert/732ec2ea8f2f593e9b78eb86b9ef6d9f.png
[004d6ea5f822bdd25626cac3f43ec140.png]: https://img-blog.csdnimg.cn/img_convert/004d6ea5f822bdd25626cac3f43ec140.png
[0b22044fd5e8b200a193d054acb11385.png]: https://img-blog.csdnimg.cn/img_convert/0b22044fd5e8b200a193d054acb11385.png
[3c96bb5aa369583165b12b23b66ca953.png]: https://img-blog.csdnimg.cn/img_convert/3c96bb5aa369583165b12b23b66ca953.png
[907b4811ea1121e89ded8934d10371a2.png]: https://img-blog.csdnimg.cn/img_convert/907b4811ea1121e89ded8934d10371a2.png
[31b8088b3a2567d69d435a2242d21dcb.png]: https://img-blog.csdnimg.cn/img_convert/31b8088b3a2567d69d435a2242d21dcb.png
[1334315f2c2564e9dc405a1c153a2c5d.png]: https://img-blog.csdnimg.cn/img_convert/1334315f2c2564e9dc405a1c153a2c5d.png
[a5ddcc31554fb44046b4d895a0cdb121.png]: https://img-blog.csdnimg.cn/img_convert/a5ddcc31554fb44046b4d895a0cdb121.png
[f563eee2c58a1ea78e8ed9e1a5c220ab.png]: https://img-blog.csdnimg.cn/img_convert/f563eee2c58a1ea78e8ed9e1a5c220ab.png
[e69c42223ee7e90277412f4be20d64e8.png]: https://img-blog.csdnimg.cn/img_convert/e69c42223ee7e90277412f4be20d64e8.png
[51b9836ffe20e8134ef64d88b8f3e6ef.png]: https://img-blog.csdnimg.cn/img_convert/51b9836ffe20e8134ef64d88b8f3e6ef.png
[51d8286346712802dedf650a50f56fa4.png]: https://img-blog.csdnimg.cn/img_convert/51d8286346712802dedf650a50f56fa4.png
[5e24da8c9aa39442dca2abb30a82bec7.png]: https://img-blog.csdnimg.cn/img_convert/5e24da8c9aa39442dca2abb30a82bec7.png
[b3b90f1a04ff7ee3193dfb1598d66815.png]: https://img-blog.csdnimg.cn/img_convert/b3b90f1a04ff7ee3193dfb1598d66815.png
[b0c996598468461896ff258da1b48c84.png]: https://img-blog.csdnimg.cn/img_convert/b0c996598468461896ff258da1b48c84.png
[3f908608bf88fa33ea2f40c722958d9b.png]: https://img-blog.csdnimg.cn/img_convert/3f908608bf88fa33ea2f40c722958d9b.png
[f4f405d332c6eba0f2f736ddeda08ede.png]: https://img-blog.csdnimg.cn/img_convert/f4f405d332c6eba0f2f736ddeda08ede.png