【C语言基础】:数据在内存中的存储

本文涉及的产品
云解析DNS,个人版 1个月
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
全局流量管理 GTM,标准版 1个月
简介: 【C语言基础】:数据在内存中的存储

一、整数在内存中的存储

在讲操作符的时候讲过,整数的二进制表示方法有三种:原码、反码和补码。对于有符号的整数,这三种表示方法均有符号位和数值位两部分,符号位用0表示“正”,用1表示“负”,最高的一位被用来当作符号位,其余的都是数值位。

有符号整数的二进制特点:


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

负数:负数的原、反、补码各不相同


  1. 原码:直接将数值按照正负数的形式翻译成⼆进制得到的就是原码。
  2. 反码:将原码的符号位不变,其他依次按位取反就可以得到反码
  3. 补码:反码加一就可以得到补码


对于整型来说:数据是以补码的形式存储在内存中。

之所以以补码的形式储存是因为在计算机中数值一律都是按补码来表示和存储,这是因为使用补码,可以将符号位和数值域统一处理;同时,加法和减法也可以同时处理(CPU只有加法器),此外,补码与原码之间相互转换,其运算过程是相同的,不需要额外的硬件电路。


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

了解了整型在内存中的存储之后,我们来调试看一下细节:

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

dc6df7c3cd31f1adcd6b3cabf546b978_6f03f71535ba437b926bd33f14a52006.png


注意:


  1. 整型在内存中是以二进制的补码进行存储的
  2. 在调试窗口查看内存时,为方便展示,显示的是十六进制的值。
  3. 这里的数值的存储顺序是倒过来的。


造成这种情况的原因是因为超过一个字节的数据在内存中存储的时候,就有储存顺序的问题,按照不同的存储顺序,我们分为大端字节序存储和小端字节序存储。

大端(存储)结构


指数据的低字节内容保存在内存的高地址处,而数据的高字节内容保存在低地址处。


小端(存储)结构


指数据的低字节内容保存再内存的低地址处,而数据的高字节内容保存在高地址处。


0x11223344中44为低位字节

c05ea988f2880845d34fb58d73614b11_2fcb893e8e5145b3af39b3e1ecf7ba4b.png

这里就可以看出当前VS是采用的小端存储。


1. 为什么有大小端?

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


例如:⼀个 16bit 的 short 型 x ,在内存中的地址为 0x0010,x 的值为 0x1122 ,那么0x11 为⾼字节,0x22 为低字节。对于大端模式,就将 0x11 放在低地址中,即 0x0010 中,0x22 放在高地址中,即 0x0011 中。小端模式,刚好相反。我们常用的 X86 结构是小端模式,而KEIL C51 则为大端模式。很多的ARM,DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。


2. 练习

【练习1】:请简述大端字节序和小端字节序的概念,设计⼀个小程序来判断当前机器的字节序。(10分)-百度笔试题


#include<stdio.h>

int check_sys()
{
  int n = 1;
  // 取n的地址,强转成char*类型,解引用一次访问一个字节
  // 1的二进制为00 00 00 01, 如果是返回的是1,说明是小端存储,反之大端
  return *((char*)&n);
}
int main()
{
  int ret = check_sys();
  if (ret == 1)
    printf("小端\n");
  else
    printf("大端\n");
  return 0;
}

69557c8844d602c5975c7b9c2b2bf917_85e505bd85984ae680e85baea48da95a.png


【练习2】:

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

分析:对于这题,我们要了解signed是有符号的,unsigned是无符号的。char类型的数据长度为1个字节,也就是八个bit位,从8个0到8个1共有256种可能也就是2的八次方。整型数据在内存中以补码的形式保存。(char是signed还是unsigned是取决于编译器,在VS上char表示signed char)


  1. signed:对于有符号的,其最高位为符号位,其余为数值位。也就会有一半的可能为正数,一半为负数,用原码打印出来后正数是0到127,负数是-1到-128。所以signed char的取指范围是-128~127。
  2. unsigned:对于无符号的,所有的数都是正数,正数的原、反、补码都相同,所以unsigned char的取指范围是0到255。

解析:


  1. 由于整型占4个字节(32个bit位),而char只占1个字节(8个bit位)。所以将 -1存入到char中,会发生截断,有32位变成8位。-1的补码为32个1组成,截断后变为8个1。所以无论a、b、c是signed还是unsigned,其在内存中都是存的8个1。
  2. printf打印a、b、c都是以**%d的形式打印,%d**是来打印有符号整型的(打印的是 原码),这里的a、b、c都是字符,要整型提升成整型后才能进行打印。有符号提升提升要补符号位(数值位不变,其余用1来填充至32位),再将补码转成原码进行打印。a和b打印出来的都是 -1,而c因为是无符号的,所以整型提升补的的0,正数的原、反、补码都相同,所以打印出来的是255。

f1e7b6b105f77d3f350f06d4f661ab38_f2b3869a005c46c3a65509ade578369e.png

【练习3】:


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

解析:数据以补码的形式存储在内存中,将整形数据存在char类型中会发生截断,32位会被截断成8位,截断后成为10000000,%u是打印无符号整型,需要发生整型提升,因为现在最高位是1,所以要全部填1补满32位,以 %u打印不需要管是正数还是负数,统一都当正数处理,32位全为数值位且原、反、补码相同,对于负数也是一样的。


d693550c13ea08d2fe9239ba61a7731f_417fedf60def4790adc48d7a5bf05a39.png

99fef0b6c819dc3802ef883d5fb95ae9_46f6cc78146248e59b33f7106068c609.png


【练习4】:


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

5f7b2e87787145381ddc794c68c26def_2f04caad638a4089b7d2943b3551f8c3.png


解析:strlen统计的是\0(ASCII码值是0)之前的字符个数。从上图可以看出这里是一个循环往复的结果,从-1-i到0之间的个数是255,所以打印的结果就是255。

ae0062647632d62045743674d65da19f_3b1cbbbc19e144aaa00520c66335f0d2.png


【练习5】:


#include<stdio.h>
//X86环境 ⼩端字节序
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;
}

分析:


  1. 数组名取取地址符&代表的是整个数组,&数组名 + 1 跳过的是整个数组。
  2. 数组强转成整型加一就是数值上的加一。



三、浮点数在内存中的存储

常见的浮点数:3.14159、1E10等,浮点数家族包括: float、double、long double 类型。

浮点数表示的范围: float.h 中定义


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

e708854ac3d2ea035a73112fcf3563f1_3579f8016676461095f2b6a4af7231a8.png


这里我们发现我们以整型的方式放进去,再以浮点型的形式拿出来的时候结果是不一样的,这说明整型和浮点型在内存中的存储方式是不一样的;下面的也同样能说明这个道理。


1. 浮点数的存储

上面的代码中, num 和 *pFloat 在内存中明明是同⼀个数,为什么浮点数和整数的解读结果会差别这么大?

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

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

2330596d507306f0686bb73759ef6f64_dad7500640954d749e6330dbd9f0b000.png

举例来说:


十进制的5.0,写成二进制是 101.0 ,相当于 1.01×2^2 。

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

十进制的-5.0,写成二进制是 -101.0 ,相当于 -1.01×2^2 。那么,S=1,M=1.01,E=2。

IEEE 754规定:


对于32位的浮点数(float),最⾼的1位存储符号位S,接着的8位存储指数E,剩下的23位存储有效数字M

对于64位的浮点数(double),最⾼的1位存储符号位S,接着的11位存储指数E,剩下的52位存储有效数字M

所以浮点数的存储,其实存储的就是S、M、E相关的值。


f7427d20a3c76194ad7cdd2f9b6f1089_c0ef6dab14194b4fbb10a965adc3f2b9.png


1.1 浮点数的存储过程

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


至于指数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。


1.2 浮点数取的过程

指数E从内存中取出还可以再分成三种情况:


1.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,则其⼆进制表示形式为:

0 01111110 00000000000000000000000
  1. E全为0
    这时,浮点数的指数E等于1-127(或者1-1023)即为真实值,有效数字M不再加上第⼀位的1,而是还原为0.xxxxxx的小数。这样做是为了表示±0,以及接近于0的很小的数字。
0 00000000 00100000000000000000000
  1. E全为1
    这时,如果有效数字M全为0,表示±无穷大(正负取决于符号位s);
0 11111111 00010000000000000000000

四、题目解析

回到最开始的那道题:


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

解析:


1.第一部分:

将9以整型的形式存储在内存中,得到的二进制为:

0000 0000 0000 0000 0000 0000 0000 1001

但当9强转成float类型时,站在pFloat的视角上,它会认为自己指向的是一个float类型的数值。

0 00000000 00000000000000000001001

将 9 的⼆进制序列按照浮点数的形式拆分,得到第⼀位符号位s=0,后面8位的指数E=00000000,最后23位的有效数字M=000 0000 0000 0000 0000 1001。由于指数E全为0,所以符合E为全0的情况。因此,浮点数V就写成:


V=(-1)^0 × 0.00000000000000000001001×2 ^(-126) = 1.001×2^(-146)


显然,V是⼀个很小的接近于0的正数,所以用十进制小数表示就是0.000000。


2.第二部分:

浮点数9.0等于⼆进制的1001.0,即换算成科学计数法是:1.001×2^3。

所以:9.0 = (−1) ∗ 0 ∗ (1.001) ∗ 2^3。

第⼀位的符号位S=0,有效数字M等于001后⾯再加20个0,凑满23位,指数E等于3+127=130,即10000010。所以,写成⼆进制形式,应该是S+E+M,即:

0 10000010 00100000000000000000000

这个32位的二进制数,被当做整数来解析的时候,就是整数在内存中的补码,原码打印出来的就是1091567616。

相关文章
|
6天前
|
存储 分布式计算 Hadoop
HadoopCPU、内存、存储限制
【7月更文挑战第13天】
33 14
|
16天前
|
存储 缓存 中间件
|
2天前
|
存储 缓存 C语言
【C语言】字符函数,字符串函数,内存函数
C语言中的字符串函数和内存函数
9 0
【C语言】字符函数,字符串函数,内存函数
|
10天前
|
存储 Java 程序员
Java面试题:方法区在JVM中存储什么内容?它与堆内存有何不同?
Java面试题:方法区在JVM中存储什么内容?它与堆内存有何不同?
35 10
|
11天前
|
存储 设计模式 监控
Java面试题:如何在不牺牲性能的前提下,实现一个线程安全的单例模式?如何在生产者-消费者模式中平衡生产和消费的速度?Java内存模型规定了变量在内存中的存储和线程间的交互规则
Java面试题:如何在不牺牲性能的前提下,实现一个线程安全的单例模式?如何在生产者-消费者模式中平衡生产和消费的速度?Java内存模型规定了变量在内存中的存储和线程间的交互规则
20 0
|
11天前
|
存储 安全 Java
Java面试题:如何在Java应用中实现有效的内存优化?在多线程环境下,如何确保数据的线程安全?如何设计并实现一个基于ExecutorService的任务处理流程?
Java面试题:如何在Java应用中实现有效的内存优化?在多线程环境下,如何确保数据的线程安全?如何设计并实现一个基于ExecutorService的任务处理流程?
13 0
|
11天前
|
安全 Java 调度
Java面试题:Java内存优化、多线程安全与并发框架实战,如何在Java应用中实现内存优化?在多线程环境下,如何保证数据的线程安全?使用Java并发工具包中的哪些工具可以帮助解决并发问题?
Java面试题:Java内存优化、多线程安全与并发框架实战,如何在Java应用中实现内存优化?在多线程环境下,如何保证数据的线程安全?使用Java并发工具包中的哪些工具可以帮助解决并发问题?
12 0
|
11天前
|
安全 算法 编译器
C++一分钟之-内存模型与数据竞争
【7月更文挑战第10天】了解C++11内存模型对多线程编程至关重要。它定义了线程间同步规则,包括顺序一致性、原子操作和内存屏障。数据竞争可能导致不确定行为,如脏读和丢失更新。可通过互斥量、原子操作和无锁编程避免竞争。示例展示了`std::mutex`和`std::atomic`的使用。掌握内存模型规则,有效防止数据竞争,确保多线程安全和性能。
15 0
|
2月前
|
存储 C语言
C语言中的数据输入输出
C语言中的数据输入输出
25 0
|
9月前
|
缓存 C语言
C语言——数据的输入输出
C语言——数据的输入输出