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

05-110阅读0评论

这是懒羊羊

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

- 一、整数在内存中的存储
- - 1.1、整数的存储方式
  - 1.2、大小端字节序
  - - （1）大小端字节序的定义
    - （2）判断大小端
    - 1.3、整型练习
    - 二、浮点数在内存中的存储
    - - 2.1、引言
      - 2.2、浮点数的存储规则
      - 2.3、浮点数的存储过程
      - 2.4、题目解析
        一、整数在内存中的存储
        1.1、整数的存储方式
        
        我们知道，整形分为有符号整形和无符号整形。对于无符号整型来说，他所有位均为数值位；而有符号整形，他的最高位代表符号位，其余位为数值位，符号位用0表示正，1表示负。
        
        $【C语言】——数据在内存中的存储,在这里插入图片描述,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,操作,没有,进行,第1张$
        注： c h a r char char类型虽然是存储字符，但本质是存其ASCII值，因此也可以看作是整形。
        注：有符号和无符号只针对整型，不包括浮点型等
        
        在【C语言】——详原解操作符（上）中，我曾提到，整数在内存中的存储有三种方式：原码、反码、补码。下面，让我们简单回顾一下。
        原码：直接将数值按他的正负数形式翻译成二进制得到的就是原码
        反码：源码的符号位不变，数值位按位取反即为反码
        补码：将反码加一，得到的就是补码
        在内存中，整数的存储和运算都是以补码的形式，只有显示给用户时，才是原码的形式。
        
        为什么呢？
        在计算机系统中，数值一律用补码来表示和存储。
        
        原因在于：使用补码，可以将数值位和符号位统一进行处理
        
        同时，加法和减法也可以统一进行处理（CPU只有加法器），此外，源码和补码相互转换，其运算过程是相同的（两者转换都是取反，加一），不需要额外的硬件电路。
        
        1.2、大小端字节序
        （1）大小端字节序的定义
        不知大家在平时调试代码时，大家有没有发现一个奇怪的现象：整型在内存中好像是倒着存的。
        
        如图：
        $【C语言】——数据在内存中的存储,在这里插入图片描述,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,操作,没有,进行,第2张$
        
        上图显示的是整型变量 a a a 在内存中的存储情况，按我们的习惯不应该是：00 00 00 01 吗？为什么是 01 00 00 00 呢？
        
        上面这种存储方式叫小端字节序存储
        
        首先，我们来看看什么是大小端。
        
        在内存中，数据是以内存为单位进行存储的，那么，超过一个字节大小的数据的存储就不可避免的涉及到存储顺序问题，按照不同的存储顺序，我们分为大端字节序存储和小端字节序存储，下面是具体概念。
        小端字节序存储：指数据的低位字节内容保存在内存中的低地址处，而数据的高字节内容保存在内存的高地址处。
        大端字节序存储：指数据的高位字节内容保存在内存的低地址处，而数据的低字节内容保存在内存的高地址处。
        数据是大端还是小端存储并不由编译器决定，而是取决于硬件设备。
        
        为什么会分大小端呢？
        这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为 8 个 b i t bit bit 位，但是在 C语言中除了 8 b i t bit bit 的 c h a r char char 之外，还有 16 b i t bit bit 的 s h o r t short short
        类型，32 b i t bit bit 的 l o n g long long 类型（要看具体的编译器），另外，对于位数大于 8 位的处理器，例如 16 位或者 32 位的处理器，由于寄存器宽度大于一个字节，那么就必然存在着如何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。
        
        例如：一个 16 b i t bit bit 的 s h o r t short short 类型 x x x ，在内存中的地址为 0 x 0010 0x0010 0x0010， x x x 的值为 0 x 1122 0x1122 0x1122 ，那么 0 x 11 0x11 0x11 为高字节， 0 x 22 0x22 0x22 为低字节。对于大端模式，就将 0 x 11 0x11 0x11 放在低地址中，即 0 x 0010 0x0010 0x0010 中， 022 022 022 放在高地址中，即放在 0 x 0011 0x0011 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 i i 的地址，因为 c h a r char char* 型指针只会访问一个字节的内容，所以将其强制类型转换成 c h a r char char* 类型，再对其进行解引用。
        同时我们还知道：一个变量的地址，是其所有字节的地址中，地址最小的字节的地址。因此解引用得到的是 i i i 中最小字节地址所存储的内容，如果存储值为 1，则为小端存储，如果为 0，则为大端存储
        
        当然，，我们还可以用联合体来判断
        
        int check_sys() { union { int i; char c; }un; un.i = 1; return un.c; }
        
        关于联合体的知识，我们放到后面去讲
        
        1.3、整型练习
        
        练习一：
        
        #include 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;： c h a r char char 类型是（ s i g n e d ） c h a r （signed）char （signed）char 还是（ u n s i g n e d c h a r ）（unsigned char）（unsignedchar）取决于具体编译器的实现，但大部分是（signed）char。
        -1 的补码是 11111111 11111111 11111111 11111111（整数默认4个字节），因为 c h a r char char 只有一个字节大小，发生截断， a a a 中放的是 11111111。同理char b=-1中 b b b 中放的也是11111111。
        接下来，我们来看unsigned char c = -1;： c c c 中存放的也是 11111111，虽然 -1 是负数，但是存还是照样存的（先把数据存进去再说）
        虽然 a b c abc abc 里存的都是 8 个 1 ，但以什么方式看待这 8 个 1 是不同的，对 a b ab ab 来说，他们认为 8 个 1 是 -1，而对 c c c 来说，他认为 8 个 1 是 255。
        再来看最后一句，首先，我们要知道％d是以有符号整型来打印，打印 a b c abc abc 时，他们要先发生整形提升（详情请看【C语言】——详解操作符（下））。
        对 a b ab ab 来说他们是有符号类型，整形提升按他们的符号位进行提升，即 11111111 11111111 11111111 11111111，补码转为源码，打印的结果是 -1。
        而对于 c c c 来说他是无符号类型，整形提升高位补 0，即 00000000 00000000 00000000 11111111，因为首位是 0，被认为是正数，正数的原反补码相同，结果为 255。
        答案：-1、-1、255
        
        练习二：
        
        #include int main() { char a = -128; char b = 128; printf("a=%u, b=%u\n", a, b); return 0; }
        
        我们先来看 a a a
        首先，我们来看 -128 的原码反码补码
        原码：10000000 00000000 00000000 10000000
        反码：11111111 11111111 11111111 0111111
        补码：11111111 11111111 11111111 10000000
        a a a 存储时，发生截断，存后面 8 个 b i t bit bit 位，即 10000000
        ％u是以无符号整型来打印数据，打印前， a a a 先发生整形提升，因为 c h a r char char 为有符号类型，整型提升按符号位提升，即 11111111 11111111 11111111 1000000，而％u认为他是无符号数，因此打印的是一个很大的数。
        同理， b b b 也是类似的分析方法
        答案：a=4294967168, b=4294967168
        
        练习三：
        
        #include #include int main() { char a[1000]; int i; for (i = 0; i
        
        让我们一起来分析这道题
        
        数组 a a a 中存放的是 c h a r char char类型的数据，通过 f o r for for 循环，依次放入 -1，-2，-3 ······ 等数据，循环 1000 次。而因为 a a a 中元素是 c h a r char char类型，范围是 -128至127，因此放入的数据会周期循环。
        而题目要求打印的是strlen(a)的值，我们知 s t r l e n strlen strlen函数是计算字符串的长度，遇到 ‘\0’ 停止计算，而 ‘\0’ 的本质是 0，因此这题的核心思路就是：计算第一次放入0，是第几个数放入，再减去一，即可知道前面翻入几个数，即字符串长度。
        
        $【C语言】——数据在内存中的存储,在这里插入图片描述,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,操作,没有,进行,第3张$
        
        答案：255
        
        练习四：
        
        #include int main() { unsigned char i = 0; for (i = 0; i printf("hello world\n"); } return 0; } unsigned int i; for (i = 9; i = 0; i--) { printf("%u\n", i); } return 0; }
        
        同理，这段代码也是如此，一样是死循环
        
        练习五：
        
        #include 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; }
        
        首先我们来看 p t r 1 ptr1 ptr1：& a a a 取出的是整个数组的地址，+1 则是跳过了整个数组，之后将该地址强制类型转换成 i n t int int * 类型。％x 是以十六进制的方式打印数据， p t r 1 [ − 1 ] ptr1[-1] ptr1[−1] 等价于 * （ p t r − 1 ）（ptr -1）（ptr−1），由于 p t r 1 ptr1 ptr1 是整型指针，-1 后退 4 个字节指向元素 4
        
        图示：
        
        $【C语言】——数据在内存中的存储,在这里插入图片描述,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,操作,没有,进行,第4张$
        
        接着我们来看 p t r 2 ptr2 ptr2，首先 a a a 是数组首元素的地址，取出后将其强制类型转换成整型变量，后面 +1，即数学上的+1，指针向后移动一位。
        再将该整数强制类型转换成整型指针，最后，以十六进制打印 p t r 2 ptr2 ptr2 解引用的值，因为强转成 i n t int int* 指针，所以访问权限为 4 个字节。
        
        $【C语言】——数据在内存中的存储,在这里插入图片描述,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,操作,没有,进行,第5张$
        
        因为为小端存储，所以取出的数实际为 02 00 00 00
        答案：4 2000000
        
        二、浮点数在内存中的存储
        2.1、引言
        像 3.14159、1E10 等数被称为浮点数。
        首先我来问问大家，浮点数为什么叫浮点数呢？
        我们来看个例子： 123.45 123.45 123.45 = 12.345 ∗ 1 0 1 12.345*10^1 12.345∗101 = 1.2345 ∗ 1 0 2 1.2345 * 10^2 1.2345∗102
        可以看到，该数的小数点是可以左右浮动的，因此被称为浮点数。
        
        浮点数家族包括 f l o a t float float、 d o u b l e double double、 l o n g d o u b l e long double longdouble 等类型，浮点数的表示范围，在中定义
        
        接下来，让我们看一道习题，开启接下来的浮点数学习之旅。
        
        #include 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; }
        
        输出结果：
        $【C语言】——数据在内存中的存储,在这里插入图片描述,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,操作,没有,进行,第6张$
        为什么会这样呢？按我们之前的知识，四个答案应该是：9、9.0、9、9.0 。但现在，只有两个正确，为什么呢？
        
        我们先粗略分析一下原因
        我们以整型形式放，以浮点型形式取出，有问题
        我们以浮点型的形式放，以整型的形式取出，也有问题
        我们不妨做一个大胆的猜测：整型和浮点型在内存中的存储有很大差异。
        
        那到底是不是这样呢？我们一起来学习浮点型在内存中的存储。
        
        2.2、浮点数的存储规则
        根据国际标准 IEEE(电气和电子工程协会)754，任意一个浮点数 V 可以表示成下面的形式
        $【C语言】——数据在内存中的存储,在这里插入图片描述,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,操作,没有,进行,第7张$
        
        举例来说：
        十进制的 5.0 5.0 5.0，用二进制表示是 101.0 101.0 101.0，可写成 1.01 ∗ 2 2 1.01*2^2 1.01∗22。那么，按上面 V 的形式，他的 S=0、 M=1.01、 E=2
        
        十进制的 − 5.0 -5.0 −5.0，用二进制表示是 − 101.0 -101.0 −101.0，可写成 − 1.01 ∗ 2 2 -1.01*2^2 −1.01∗22 那么，按上面 V 的形式，它的 S=1、 M=1.01、 E=2
        
        IEEE 754 规定：
        
        对于 32 位（ f l o a t float float）的浮点数，最高的一位存储的是符号位 S，接着 8 位存储指数位 E，剩下的 23 位存储有效数字 M
        $【C语言】——数据在内存中的存储,在这里插入图片描述,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,操作,没有,进行,第8张$
        
        而对于 64 位（ d o u b l e double double）的浮点数，最高的一位存储的是符号位S，接着11位存储指数位E，剩下的52位存储有效数字M
        $【C语言】——数据在内存中的存储,在这里插入图片描述,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,操作,没有,进行,第9张$
        
        2.3、浮点数的存储过程
        
        IEEE 754 对有效数字 M 和指数 E 还有一些特别规定
        我们前面说过，M 的取值 1

相关阅读：

1、替换FeedBurner邮件为Follow.it

2、使用正则表达式进行中文排版

3、Windows 10下注册32位OCX控件的方法

4、小储云商城V1.78破解版

5、wordpress阿里百xiu主题破解版

文章版权声明：除非注明，否则均为VPS857原创文章，转载或复制请以超链接形式并注明出处。

【华为笔试题汇总】[重制版+笔试经验分享] 2024-03-20-华为春招笔试题-三语言题解(Python/Java/Cpp)

【Java--数据结构】链表经典OJ题详解（下）

相关阅读

WPS二次开发系列：如何使用WPS返回的FileUri

WPS加载项(wps jsapi)创建及部署--新版

GraphQL在现代Web应用中的应用与优势

【半夜学习MySQL】表结构的操作（含表的创建、修改、删除操作，及如何查看表结构）

GraphQL和RESTful的对比：通过实际的示例来介绍GraphQL的构成和操作方式，并和传统的RESTful API进行比较，分析它们的优劣势

目标检测算法YOLOv7简介

计算机视觉与深度学习实战：以Python为工具，基于块匹配的全景图像拼接

Express框架下搭建GraphQL API

发表评论取消回复

评论列表（暂无评论，0人围观）

还没有评论，来说两句吧...

目录[+]

微信二维码

微信二维码

支付宝二维码