深度剖析数据在内存中的存储

简介: 深度剖析数据在内存中的存储

1. 数据类型介绍

前面我们已经学习了基本的内置类型:

1. char //字符数据类型
2. short //短整型
3. int //整形
4. long //长整型
5. long long //更长的整形
6. float //单精度浮点数
7. double //双精度浮点数
8. //C语言有没有字符串类型?

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

类型的意义:

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

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

1.1 类型的基本归类

整形家族:

char

unsigned char

signed char

short

unsigned short [int]

signed short [int]

int

unsigned int

signed int

long

unsigned long [int]

signed long [int]

浮点数家族:

float

double

构造类型:

> 数组类型

> 结构体类型 struct

> 枚举类型 enum

> 联合类型 union

指针类型:

int *pi;

char *pc;

float* pf;

void* pv;

空类型:

void 表示空类型(无类型)

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

2. 整形在内存中的存储

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


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

比如:

1. int a = 20;
2. int b = -10;

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

那如何存储?

下来了解下面的概念:


2.1 原码、反码、补码

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

三种表示方法均有符号位和数值位两部分,符号位都是用0表示“正”,用1表示“负”,而数值位

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

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

原码

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

反码

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

补码

反码+1就得到补码。

对于整形来说:数据存放内存中其实存放的是补码。

为什么呢?

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

一处理;

同时,加法和减法也可以统一处理(CPU只有加法器)此外,补码与原码相互转换,其运算过程

是相同的,不需要额外的硬件电路。

有时候我们观察内存的话,会发现存储的补码顺序不一样,这是为什么呢?

2.2 大小端介绍

什么大端小端:

大端(存储)模式,是指数据的低位保存在内存的高地址中,而数据的高位,保存在内存的低地址

中;

小端(存储)模式,是指数据的低位保存在内存的低地址中,而数据的高位,,保存在内存的高地

址中。

如果a地地址是0x11223344,那么将11这个高位字节放在低地址处就是大端字节序存储,将44这个低位字节放在低地址处就是小端字节序存储。

为什么有大端和小端:

为什么会有大小端模式之分呢?这是因为在计算机系统中,我们是以字节为单位的,每个地址单元

都对应着一个字节,一个字节为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处理器还可以由硬件来选择是大端模式

还是小端模式。

百度2015年系统工程师笔试题:


请简述大端字节序和小端字节序的概念,设计一个小程序来判断当前机器的字节序。


我们将1赋给整形变量a,判断大小端存储我们只需要拿出a的地址的第一个字节,判断是不是1,如果是1则为小端字节序存储,否则是大端字节序存储。访问一个字节我们用到char*类型。。

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

2.3 练习

输出什么?

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


这是为什么呢?


我们知道char只能存1个字节就是8个bit位,所以a,b,c存进去的都是11111111,但是%d是10进制的形式打印有符号的整数,所以默认打印的值是有符号的,a是char类型的,所以打印的时候要发生整形提升,有符号的char高位是符号位,所以前面补1,然后转换成补码就可以打印了。c是无符号的char,也要整形提升,没有符号前面补0,补了0之后默认为是有符号数,所以最高位0被认为是符号位,所以是255.

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
  char a = -1;
  //10000000000000000000000000000001
  //11111111111111111111111111111110
  //11111111111111111111111111111111
  //11111111 - a
  signed char b = -1;
  //11111111 - b
  unsigned char c = -1;
  //11111111 - c
  printf("a=%d,b=%d,c=%d", a, b, c);
  //%d 是10进制的形式打印有符号的整数
  //00000000000000000000000011111111
  return 0;
}

输出什么?

1. #define _CRT_SECURE_NO_WARNINGS 1
2. #include<stdio.h>
3. int main()
4. {
5.  char a = -128;
6.  printf("%u\n", a);
7.  return 0;
8. }

首先我们计算出-128的补码,%u 是10进制的形式,打印无符号的整数,所以认为最高位不是符号位。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
  char a = -128;
  //10000000000000000000000010000000
  //11111111111111111111111101111111
  //11111111111111111111111110000000
  //10000000 - a
  //11111111111111111111111110000000
  printf("%u\n", a);
  //%u 是10进制的形式,打印无符号的整数
  //%d 是10进制的形式,打印有符号的整数
  return 0;
}


我们来看这道题:

1. #include <stdio.h>
2. int main()
3. {
4. char a = 128;
5.   printf("%u\n",a);
6. return 0;
7. }

这两段代码的结果是一样的,因为存进去的都是10000000。

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


其实char的范围是-128~127,怎么说呢?

假设char是有符号的char,那么就是存储8个bit位,内存存储的是补码,最大的正数是127,对应的二进制序列是01111111,最小的数就是-128,对应的二进制序列是-128。

假设char是无符号的unsigned char,最高位就不是符号位了,只能表示正数。

我们来看这个代码:

用补码相加之后%d默认有符号,所以我们要计算原码。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
  int i = -20;
  //10000000000000000000000000010100
  //11111111111111111111111111101011
  //11111111111111111111111111101100
  unsigned int j = 10;
  //00000000000000000000000000001010 -原反补码相同
  //11111111111111111111111111101100 
  //11111111111111111111111111110110 -相加 %d默认有符号,计算原码
  //10000000000000000000000000001001
  //10000000000000000000000000001010 -10
  printf("%d\n", i + j);
  return 0;
}

我们再来看一段代码:


这段代码的结果是死循环,这是为什么呢?因为unsigned int二进制序列最小也是0,所以for循环的判断部分恒成立,所以代码打印完9~0后就会死循环

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

我们再看一个小练习:


我们都知道strlen统计的是\0之前的字符,在for循环之后a里面放的是,-1 -2 -3 -4 -5 .. -128 127 .. 6 5 4 3 2 1 0,-1- -128之间是128个数字,127-1是127个数字,之后在遇到0,\0的ASCLL码值是0,所以是255个字符。

#define _CRT_SECURE_NO_WARNINGS 1
#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;
}


这段代码会死循环,因为unsigned  int的最大值就是255,所以判断条件恒成立。

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

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

常见的浮点数:

3.14159

1E10

浮点数家族包括: float、double、long double 类型。

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

3.1 一个例子

浮点数存储的例子:

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

n的值是没有争议的,第二个*pFloat也是没问题的,那为什么第一个*pFloat会是这个结果呢?以整形的形式存进去,以浮点型的形式拿出来答案会不一样吗?这说明整数的存储形式和浮点型不一样。所以我们以什么方式存进去就要方式取出来,这样才不会出错。

3.2 浮点数存储规则

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

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

详细解读:

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

(-1)^S * M * 2^E

(-1)^S表示符号位,当S=0,V为正数;当S=1,V为负数。

M表示有效数字,大于等于1,小于2。

2^E表示指数位。

举例来说:

十进制的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。IEEE754规定:

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



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

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。

然后,指数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,则其二进

制表示形式为:

E全为0

这时,浮点数的指数E等于1-127(或者1-1023)即为真实值,

有效数字M不再加上第一位的1,而是还原为0.xxxxxx的小数。这样做是为了表示±0,以及接近于

0的很小的数字。

0 01111110 00000000000000000000000

E全为1

这时,如果有效数字M全为0,表示±无穷大(正负取决于符号位s);

解释前面的题目:

下面,让我们回到一开始的问题:为什么 0x00000009 还原成浮点数,就成了 0.000000 ?

首先,将 0x00000009 拆分,得到第一位符号位s=0,后面8位的指数 E=00000000 ,

最后23位的有效数字M=000 0000 0000 0000 0000 1001。


9 -> 0000 0000 0000 0000 0000 0000 0000 1001

由于指数E全为0,所以符合上一节的第二种情况。因此,浮点数V就写成:

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

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

再看例题的第二部分。

请问浮点数9.0,如何用二进制表示?还原成十进制又是多少?

首先,浮点数9.0等于二进制的1001.0,即1.001×2^3。

9.0 -> 1001.0 ->(-1)^01.0012^3 -> s=0, M=1.001,E=3+127=130


那么,第一位的符号位s=0,有效数字M等于001后面再加20个0,凑满23位,指数E等于3+127=130,

即10000010。

所以,写成二进制形式,应该是s+E+M,即


0 10000010 001 0000 0000 0000 0000 0000


这个32位的二进制数,还原成十进制,正是 1091567616。


相关文章
|
5天前
|
存储 编译器 C语言
C语言:数据在内存中的存储形式
C语言:数据在内存中的存储形式
|
1月前
|
存储 搜索推荐 编译器
C learning_11 (数组和在内存存储的理解、数组越界、数组作为形参)
C learning_11 (数组和在内存存储的理解、数组越界、数组作为形参)
|
1月前
|
存储
数据在内存中的存储
数据在内存中的存储
30 0
|
1月前
|
存储 C语言
[C语言]数据在内存中的存储(浮点数篇)
[C语言]数据在内存中的存储(浮点数篇)
31 0
|
1月前
|
存储 编译器
关于数据在内存中的存储(整形篇)
关于数据在内存中的存储(整形篇)
39 0
|
29天前
|
Linux
|
1月前
|
监控 关系型数据库 MySQL
innodb_buffer_pool_instances 如何根据cpu和内存进行配置
`innodb_buffer_pool_instances` 是用于配置 InnoDB 缓冲池实例数的参数。每个实例都管理缓冲池的一部分,这有助于提高并发性能。通常,你可以根据系统的 CPU 和内存来调整这个参数,以获得更好的性能。 以下是一些建议和步骤,帮助你根据 CPU 和内存进行 `innodb_buffer_pool_instances` 的配置: 1. **了解系统资源:** 首先,了解系统的硬件资源,特别是内存和CPU。检查系统上可用的物理内存和 CPU 核心数量。 2. **考虑每个实例的大小:** 在配置 `innodb_buffer_pool_instances` 时,
|
1天前
|
弹性计算 大数据 测试技术
阿里服务器租用多少钱一年?阿里云服务器租用价格表(最新CPU/内存/带宽/磁盘收费标准)
阿里服务器租用多少钱一年?阿里云服务器租用价格表(最新CPU/内存/带宽/磁盘收费标准)。阿里云服务器的租用费用因实例类型、地域、配置等因素而有所不同,价格范围可以从几百元到几千元不等。2024年阿里云服务器租用费用价格表更新,云服务器ECS经济型e实例2核2G、3M固定带宽99元一年、ECS u1实例2核4G、5M固定带宽、80G ESSD Entry盘优惠价格199元一年,轻量应用服务器2核2G3M带宽轻量服务器一年61元、2核4G4M带宽轻量服务器一年165元12个月、2核4G服务器30元3个月,幻兽帕鲁4核16G和8核32G服务器配置,云服务器ECS可以选择经济型e实例、通用算力u1实
|
2天前
|
弹性计算
2024阿里云幻兽帕鲁/Palworld服务器价格表(CPU/内存/带宽/磁盘收费标准)
2024年阿里云幻兽帕鲁专用服务器的价格根据不同的配置有所不同。 • 4核16G配置的价格为32元/月,如果选择购买3个月,则价格为96元。 • 8核32G配置的价格为90元/月,如果选择购买3个月,则价格为271元。 另外,还有配置为4核16G10M带宽的服务器,其价格为26元/月起。而8核32G10M带宽的价格也是90元/月。
14 1
|
3天前
|
弹性计算 大数据 测试技术
2024阿里云服务器租用价格表(CPU/内存/带宽/磁盘收费标准)
阿里云服务器分为轻量应用服务器和云服务器ECS,轻量适合个人开发者使用,搭建轻量级的网站、测试环境使用;专业级如大数据、科学计算、高并发网站等需要使用云服务器ECS。2024年阿里云服务器租用价格表出炉!云服务器ECS经济型e实例2核2G、3M固定带宽99元一年、ECS u1实例2核4G、5M固定带宽、80G ESSD Entry盘优惠价格199元一年,轻量应用服务器2核2G3M带宽轻量服务器一年61元、2核4G4M带宽轻量服务器一年165元12个月、2核4G服务器30元3个月,幻兽帕鲁4核16G和8核32G服务器配置,云服务器ECS可以选择经济型e实例、通用算力u1实例、ECS计算型c7、通

热门文章

最新文章

相关产品

  • 云迁移中心