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

avatar
作者
猴君
阅读量:0

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

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


文章目录

前言

哈喽,各位小伙伴大家好!我们都知道计算机的数据都是存储在内存中的。那它是如何存储,以什么形式存储,存储方法又是什么呢?今天小编就带着大家一起去学习数据在内存中的存储。向着大厂冲锋!


一.整数在内存中的存储

1.1整数的表示形式

整数的2进制表示方法有三种,即原码、反码和补码。

三种表示方法均有符号位和数值位两部分,
符号位都是用0表示“正”,用1表示“负”,
而数值位最高位的⼀位是被当做符号位,剩余的都是数值位。

  • 正数:
    正整数的原、反、补码都相同。

  • 负数:
    负整数的三种表示方法各不相同。
    原码:直接将数值按照正负数的形式翻译成⼆进制得到的就是原码。
    反码:将原码的符号位不变,其他位依次按位取反就可以得到反码。
    补码:反码+1就得到补码。

    注意,补码转原码有两种方式。
    一:先-1后取反。
    二:先取反后+1。


1.2整数在内存中的存放

对于整形来说:数据存放内存中其实存放的是补码。
在计算机系统中,数值⼀律⽤补码来表示和存储。
为什么呢?

  • 使用补码,可以将符号位和数值域统⼀处理。
  • 加法和减法也可以统⼀处理(CPU只有加法器),可以将减法转化为加法运算。这是用原码计算是错误的,使用补码才能正确运算。
  • 补码与原码相互转换,其运算过程是相同的,都可以按取反+1转化,不需要额外的硬件电路。

二.大小端字节序和字节序判断

当我们了解了整数在内存中存储后,我们调试看⼀个细节:

#include <stdio.h> int main() {  int a = 0x11223344;  return 0; } 

调试的时候,我们可以看到在a中的 0x11223344 这个数字是按照字节为单位,倒着存储的。
这是为什么呢?
这就涉及到大小段字节序的问题了。


2.1大小端的概念

其实超过⼀个字节的数据在内存中存储的时候,就有存储顺序的问题。
我们来想一个问题

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

我们只需要取出变量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 <stdio.h> int main() { 	char a = -128; 	printf("%u\n", a); 	return 0; } 
  • 补码存储

    这里我们写出-128的补码。

  • 截断

  • 整型提升
    %u认为内存存放的是无符号数。
    a是char类型,需要发生整形提升。

  • 验证:


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


所以这两个代码的输出一样。

  • 验证:

3.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; } 

我们再来看这道题。
首先我们需要知道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 <stdio.h> 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 <stdio.h> 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 <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; } 

小端字节序,X86环境下代码输出的结果是啥?

  • ptr1[-1]
    在这里插入图片描述
    这里大家注意指针的类型和强制类型转化即可。
  • *ptr2

    大家看一下图解。
  • 验证:

    这里再跟大家说一下为啥是x86的环境。
    因为x64的环境这段代码执行不了为啥呢?
    因为x64指针大小是8个字节,int是四个字节。
    强转的过程会发生截断,那就会有数据的丢失。
    后面再强转成指针时就会有野指针的风险,所以无法执行。
  • 验证:

四.浮点数在内存中的存储

常见的浮点数:3.14159、1E10等,浮点数家族包括: float、double、long double 类型。
浮点数表示的范围: float.h 中定义

4.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("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 

这是我们再来看回开始的代码

所以代码输出就是:


后言

这就是数据再内存中的存储啦!这些知识看似不起眼,其实都是在修炼我们编程学习的内功。大家下去一定要认真学习。感谢大家的垂阅。今天就分享到这里,咱们下期见!拜拜~

广告一刻

为您即时展示最新活动产品广告消息,让您随时掌握产品活动新动态!