C语言数据在内存中的存储

您现在的位置：首页后端 C语言数据在内存中的存储

C语言数据在内存中的存储

码农世界 2024-05-31 后端 78 次浏览 0个评论

C语言数据在内存中的存储

个人主页：大白的编程日记
个人专栏：C语言学习之路

文章目录

C语言数据在内存中的存储
- 前言
- 一.整数在内存中的存储
- - 1.1整数的表示形式
  - 1.2整数在内存中的存放
  - 二.大小端字节序和字节序判断
  - - 2.1大小端的概念
    - 2.2为什么有大小端
    - 三.练习
    - - 3.1整型提升
      - 3.2算术转换
      - 3.3练习一（百度笔试题）
      - 3.4练习二
      - 3.5练习三
      - 3.6练习四
      - 3.7练习五
      - 3.8练习六
      - 四.浮点数在内存中的存储
      - 4.1练习
        4.2浮点数的存储
        4.3浮点数存的过程
        4.4浮点数取的过程
        后言
        前言
        
        哈喽，各位小伙伴大家好！我们都知道计算机的数据都是存储在内存中的。那它是如何存储，以什么形式存储，存储方法又是什么呢？今天小编就带着大家一起去学习数据在内存中的存储。向着大厂冲锋！
        
        一.整数在内存中的存储
        
        1.1整数的表示形式
        
        整数的2进制表示方法有三种，即原码、反码和补码。
        
        三种表示方法均有符号位和数值位两部分，
        符号位都是用0表示“正”，用1表示“负”，
        而数值位最高位的⼀位是被当做符号位，剩余的都是数值位。
        
        正数：
        正整数的原、反、补码都相同。
        
        负数：
        负整数的三种表示方法各不相同。
        原码：直接将数值按照正负数的形式翻译成⼆进制得到的就是原码。
        反码：将原码的符号位不变，其他位依次按位取反就可以得到反码。
        补码：反码+1就得到补码。
        注意，补码转原码有两种方式。
        一：先-1后取反。
        二：先取反后+1。
        
        1.2整数在内存中的存放
        
        对于整形来说：数据存放内存中其实存放的是补码。
        在计算机系统中，数值⼀律⽤补码来表示和存储。
        为什么呢？
        
        使用补码，可以将符号位和数值域统⼀处理。
        加法和减法也可以统⼀处理（CPU只有加法器），可以将减法转化为加法运算。这是用原码计算是错误的，使用补码才能正确运算。
        补码与原码相互转换，其运算过程是相同的，都可以按取反+1转化，不需要额外的硬件电路。
        
        二.大小端字节序和字节序判断
        
        当我们了解了整数在内存中存储后，我们调试看⼀个细节：
        
        #include int main() { int a = 0x11223344; return 0; }
        
        调试的时候，我们可以看到在a中的 0x11223344 这个数字是按照字节为单位，倒着存储的。
        这是为什么呢？
        这就涉及到大小段字节序的问题了。
        
        2.1大小端的概念
        
        其实超过⼀个字节的数据在内存中存储的时候，就有存储顺序的问题。
        我们来想一个问题
        
        #include int main() { int a = 0x11223344; return 0; }
        
        如果我们要把a存在内存里我们该怎么存。
        比如这四种存放顺序。
        其实只要保证存放时的数据和我们拿出来的数据是一样的，
        任何顺序都可以。
        但是为了为了方便理解，我们就选用第一和第二种存放方式。
        这两种就会大端字节序存放和小端字节序存放。、
        
        大端字节序存储
        将一个数据低位字节的内容存放到高地址，把高位字节的内容存放到低地址处。
        
        小端字节序存储
        将一个数据高位字节的内容存放到高地址，把低位字节的内容存放到低地址处。
        
        注意无论是大端还是小段存储，我存放的是什么，从内存拿出来时就是什么。不会因为倒着存放，拿出来的数据就是倒着的。
        
        2.2为什么有大小端
        
        这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着⼀个字节，⼀个字节为8bit位，
        但是在C语言中除了8bit的 char 之外，还有16bit的 short 型，32bit的 long 型（要看具体的编译器），另外，对于位数大于8位的处理器，例如16位或者32位的处理器，
        由于寄存器宽度大于⼀个字节，那么必然存在着⼀个如何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。
        
        举例
        ⼀个 16bit 的 short 型 x ，在内存中的地址为 0x0010 ， x 的值为 0x1122 ，那么0x11 为高字节， 0x22 为低字节。
        对于大端模式，就将 0x11 放在低地址中，即 0x0010 中，
        0x22 放在高地址中，即 0x0011 中。
        小端模式，刚好相反。我们常用的 X86 结构是小端模式，而KEIL C51 则为大端模式。很多的ARM，DSP都为小段模式。
        有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。
        
        三.练习
        
        3.1整型提升
        
        C语言中整型算术运算总是至少以默认整型类型的精度来进行的。
        为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。
        
        整型提升的意义
        表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度⼀般就是int的字节长度，同时也是CPU的通用寄存器的长度。
        因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。
        通用CPU（general-purposeCPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。
        //实例1 char a,b,c; ... a = b + c;
        
        b和c的值被提升为普通整型，然后再执行加法运算。
        加法运算完成之后，结果将被截断，然后再存储于a中。
        
        那如何整型提升呢？
        
        有符号整数提升是按照变量的数据类型的符号位来提升的。
        无符号整数提升，高位补0。
        //负数的整形提升 char c1 = -1; 变量c1的⼆进制位(补码)中只有8个⽐特位： 1111111 因为 char 为有符号的 char 所以整形提升的时候，⾼位补充符号位，即为1 提升之后的结果是： 11111111111111111111111111111111 //正数的整形提升 char c2 = 1; 变量c2的⼆进制位(补码)中只有8个⽐特位： 00000001 因为 char 为有符号的 char 所以整形提升的时候，⾼位补充符号位，即为0 提升之后的结果是： 00000000000000000000000000000001 //⽆符号整形提升，⾼位补0
        
        3.2算术转换
        
        如果某个操作符的各个操作数属于不同的类型，那么除非其中⼀个操作数的转换为另⼀个操作数的类型，否则操作就无法进行。下⾯的层次体系称为寻常算术转换。
        
        long double double float unsigned long int long int unsigned int int
        
        如果某个操作数的类型在上面这个列表中排名靠后，那么首先要转换为另外⼀个操作数的类型后执行运算。
        
        3.3练习一（百度笔试题）
        
        请简述大端字节序和小端字节序的概念，设计⼀个小程序来判断当前机器的字节序。（10分）-百度笔试题
        以1为例。
        我们只需要拿到低地址处的字节内容即可。
        那怎样才能拿到呢？
        
        #include 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; }
        
        我们只需要取出变量i的地址,因为&取出的总是低地址的那个字节地址。
        但是因为是int类型，而我们只需要一个字节，所以我们强制类型转化为char*。
        再解引用即可访问低地址的那个字节，再判断是1还是0即可。
        
        验证：
        
        3.4练习二
        
        int main() { char a = -1; signed char b = -1; unsigned char c = -1; printf("a=%d,b=%d,c=%d", a, b, c); return 0; }
        
        上面的代码会输出啥？
        首先我们需要知道signed char和unsigned char的区别。
        
        signed char
        
        unsigned char
        我们现在再回到题目。
        
        补码存储
        因为内存中存储的是二进制的补码，所以我们先把-1的补码写出来。
        
        截断
        因为-1是整数，放在char类型变量需要发生截断，只保留后八位比特位。
        
        整型提升
        注意char是有符号的char还是无符号的char是取决于编译器的！
        在vs中char等价于signed char。
        
        char a = -1; signed char b = -1; unsigned char c = -1; printf("a=%d,b=%d,c=%d", a, b, c);
        
        因为是%d打印，%d是打印有符号整数。所以这里需要发生整型提升。
        整型提升有符号数按照符号位填充，无符号数用0填充。
        所以结果就是-1 -1 255。
        
        验证
        所以数据在存储时不会关心是否是有符号数还是无符号数。
        输出时才会考虑是否是有符号数还是无符号数。
        
        3.5练习三
        
        #include int main() { char a = -128; printf("%u\n", a); return 0; }
        
        补码存储
        这里我们写出-128的补码。
        
        截断
        
        整型提升
        %u认为内存存放的是无符号数。
        a是char类型，需要发生整形提升。
        
        验证：
        
        #include int main() { char a = 128; printf("%u\n",a); return 0; }
        
        所以这两个代码的输出一样。
        
        验证：
        
        3.6练习四
        
        #include int main() { char a[1000]; int i; for(i=0; i<1000; i++) { a[i] = -1-i; } printf("%d",strlen(a)); return 0; }
        
        我们再来看这道题。
        首先我们需要知道strlen求得是字符串的长度，
        统计\0之前字符的个数，\0的ASCLL码值是0。
        所以这道题的意思就是统计在0之前的字符数。
        那我们怎么找呢？
        我们前面说过signed char的取值范围是-128到217。
        那如果超出范围会怎样呢？
        大家来看图解。
        如果超出范围内存中存的数据就会继续绕圈循环。
        顺时针看是+1的循环，逆时针看是-1的循环。
        
        for(i=0; i<1000; i++) { a[i] = -1-i; }
        
        题目的for循环是-1,那我们就逆时针看。
        数字变化过程就应该是这样的：
        所以答案应该是255。
        
        验证：
        
        3.7练习五
        
        #include unsigned char i = 0; int main() { for(i = 0;i<=255;i++) { printf("hello world\n"); } return 0; }
        
        我们来看这个代码。
        这是无符号的char的循环图。
        所以unsigned char的取值范围为0到255。
        所以i<=255的条件恒成立，代码死循环。
        
        #include int main() { unsigned int i; for(i = 9; i >= 0; i--) { printf("%u\n",i); } return 0; }
        
        同理unsigned int存在内存的数据永远>=0.
        所以i >= 0判断条件恒成立。代码也是死循环。
        
        3.8练习六
        
        #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; }
        
        小端字节序，X86环境下代码输出的结果是啥？
        
        ptr1[-1]
        这里大家注意指针的类型和强制类型转化即可。
        *ptr2
        大家看一下图解。
        验证：
        这里再跟大家说一下为啥是x86的环境。
        因为x64的环境这段代码执行不了为啥呢？
        因为x64指针大小是8个字节，int是四个字节。
        强转的过程会发生截断，那就会有数据的丢失。
        后面再强转成指针时就会有野指针的风险，所以无法执行。
        验证：
        
        四.浮点数在内存中的存储
        
        常见的浮点数：3.14159、1E10等，浮点数家族包括： float、double、long double 类型。
        浮点数表示的范围： float.h 中定义
        
        4.1练习
        
        #include int main() { int n = 9; float *pFloat = (float *)&n; printf("n的值为：%d\n",n); printf("*pFloat的值为：%f\n",*pFloat); *pFloat = 9.0; printf("num的值为：%d\n",n); printf("*pFloat的值为：%f\n",*pFloat); return 0; }
        
        大家来看看这段代码，大家觉得会输出啥？
        可能很多小伙伴都会觉得时9 9.0 9 9.0 。
        但其实不是。
        通过观察我们可以发现，只有当我们以整型存储并且以整形读取输出时，或者浮点数存储并且以浮点数读取输出时结果才和存储的数据一样。
        这就说明整型和都浮点型的存储和读取方式不一样。
        那浮点型的存储和读取方式是怎么样的呢？
        
        4.2浮点数的存储
        
        我们先来思考一个问题：浮点数如何用二进制表示？
        
        上面的代码中， num 和 *pFloat 在内存中明明是同⼀个数，为什么浮点数和整数的解读结果会差别这么大？
        要理解这个结果，⼀定要搞懂浮点数在计算机内部的表示方法。
        根据国际标准IEEE（电气和电子工程协会）754，任意⼀个二进制浮点数V可以表示成下面的形式：
        举例来说：
        十进制的5.0，写成二进制是 101.0 ，相当于 1.01×2^2 。
        那么，按照上面的格式，可以得出S=0，M=1.01，E=2。
        十进制的-5.0，写成⼆进制是 -101.0 ，相当于 -1.01×2^2 。那么，S=1，M=1.01，E=2。
        IEEE754规定：
        
        对于32位的浮点数(float)，最高的1位存储符号位S，接着的8位存储指数E，剩下的23位存储有效数字M
        
        对于64位的浮点数（double），最高的1位存储符号位S，接着的11位存储指数E，剩下的52位存储有效数字M。
        所以浮点数的存储过程其实就是存储S E M三个数据的过程。
        
        4.3浮点数存的过程
        
        EEE754对有效数字M和指数E，还有⼀些特别规定。
        
        前面说过， 1≤M<2 ，也就是说，M可以写成 1.xxxxxx 的形式，其中 xxxxxx 表示小数部分。
        IEEE754规定，在计算机内部保存M时，默认这个数的第⼀位总是1，因此可以被舍去，只保存后面的
        xxxxxx部分。比如保存1.01的时候，只保存01，等到读取的时候，再把第⼀位的1加上去。这样做的目的，是节省1位有效数字。以32位浮点数为例，留给M只有23位，将第⼀位的1舍去以后，等于可以保存24位有效数字。
        至于指数E，情况就比较复杂
        首先，E为⼀个无符号整数（unsigned int）。
        
        这意味着，如果E为8位，它的取值范围为0到255；如果E为11位，它的取值范围为0~2047。但是，我们知道，科学计数法中的E是可以出现负数的，所以IEEE754规定，存入内存时E的真实值必须再加上一个中间数，
        对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。比如，2^10的E是10，所以保存成32位浮点数时，必须保存成10+127=137，即10001001。
        这里我们来验证一下吧。
        
        int main() { float f = 5.5f; return 0; }
        
        因为是小端存放，所以内存是倒着存放。
        
        特殊浮点数无法精确保存
        大家注意，并不是所有浮点数都能精确表示的。
        可能会出现这种情况：
        
        验证：
        
        4.4浮点数取的过程
        
        指数E从内存中取出还可以再分成三种情况：
        
        E不全为0或不全为1
        这时，浮点数就采用下面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将有效数字M前加上第⼀位的1。
        比如：0.5的⼆进制形式为0.1，由于规定正数部分必须为1，即将小数点右移1位，则为1.0*2^(-1)，其阶码为-1+127(中间值)=126，表示为01111110，二尾数1.0去掉整数部分为0，补齐0到23位
        00000000000000000000000，则其二进制表示形式为:
        1 0 01111110 00000000000000000000000
        
        E全为0
        这时，浮点数的指数E等于1-127（或者1-1023）即为真实值，有效数字M不再加上第⼀位的1，而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于0的很小的数字。
        1 0 00000000 00100000000000000000000
        
        E全为1
        这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）；
        1 0 11111111 00010000000000000000000
        
        这是我们再来看回开始的代码
        所以代码输出就是：
        
        后言
        
        这就是数据再内存中的存储啦！这些知识看似不起眼，其实都是在修炼我们编程学习的内功。大家下去一定要认真学习。感谢大家的垂阅。今天就分享到这里，咱们下期见！拜拜~

转载请注明来自码农世界，本文标题：《C语言数据在内存中的存储》

码农世界 37815篇文章站点微博

每一天，每一秒，你所做的决定都会改变你的人生！

发表评论取消回复

评论列表（暂无评论，78人围观）参与讨论

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

Top