数据在内存中的存储(1)

简介: 数据在内存中的存储(1)


1. 数据类型介绍

前面我们已经学习了基本的内置类型以及它们所占存储空间的大小(单位:字节):

char — 字符数据类型 — 1

short — 短整型 — 2

int — 整形 — 4

long — 长整型 — 4/8

long long — 更长的整形 — 8

float — 单精度浮点数 — 4

double — 双精度浮点数 — 8

long double

类型的意义:

  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]

long long

  unsigned long long [int]

  signed long long [int]

注:

字符存储的时候,存储的是ASCII码值,是整型,所以归类的时候放在整型家族。

浮点数家族:

float

double

long double

构造类型:

数组类型

int arr1[10]; — int [10]

int arr2[5]; — int [5]

char arr3[5]; — char[5]

结构体类型 struct

枚举类型 enum

联合类型 union

指针类型:

int *pi;

char *pc;

float *pf;

void *pv;

结构体的指针

空类型:

void 表示空类型(无类型)

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

2. 整形在内存中的存储

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

#include <limits.h>
int main()
{
  INT_MAX;
  return 0;
}

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

比如:

int a = 20;
int b = -10;

我们知道为a分配四个字节的空间,那如何存储?

2.1 原码、反码、补码

计算机中的整数有三种2进制表示方法,即原码、反码和补码。三种表示方法均有符号位数值位两部分,符号位都是用0表示“正”,用1表示“负”。

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

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

原码

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

反码

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

补码

反码+1就得到补码

int main()
{
  int num = 10;//创建一个整型变量,叫num,这时num向内存申请4个字节来存放数据
  //4个字节 - 32比特位
  //00000000000000000000000000001010 - 原码
  //00000000000000000000000000001010 - 反码
  //00000000000000000000000000001010 - 补码
  int num2 = -10;
  //10000000000000000000000000001010 - 原码
  //11111111111111111111111111110101 - 反码
  //11111111111111111111111111110110 - 补码
  return 0;
}

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

为什么呢?

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

//计算1-1
//1+(-1)
// 00000000000000000000000000000001 --> 1的补码
// 11111111111111111111111111111111 --> -1的补码
// 00000000000000000000000000000000
//
//原码计算是错误的
//00000000000000000000000000000001
//10000000000000000000000000000001
//10000000000000000000000000000010 --> -2

我们看看在内存中的存储:

int main()
{
  int num = 10;//创建一个整型变量,叫num,这时num向内存申请4个字节来存放数据
  //4个字节 - 32比特位
  //00000000000000000000000000001010 - 原码
  //00000000000000000000000000001010 - 反码
  //00000000000000000000000000001010 - 补码
  int num2 = -10;
  //10000000000000000000000000001010 - 原码
  //11111111111111111111111111110101 - 反码
  //11111111111111111111111111110110 - 补码
  return 0;
}

数据在内存中存储的是补码(本质上内存中存放的是二进制,在VS上为了方便展示,显示的是16进制),但是我们发现顺序有点不对劲,这又是为什么呢?

2.2 大小端介绍

int main()
{
  int a = 0x11223344;
  return 0;
}

  1. 字节序是以字节为单位,讨论存储顺序的
  2. 大端(存储)模式,是指数据的低位保存在内存的高地址中,而数据的高位,保存在内存的低地址中
  3. 小端(存储)模式,是指数据的低位保存在内存的低地址中,而数据的高位,保存在内存的高地址中

为什么有大端和小端:

为什么会有大小端模式之分呢?这是因为在计算机系统中,我们是以字节为单位的,每个地址单元都对应着一个字节,一个字节为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处理器还可以由硬件来选择是大端模式还是小端模式。

设计一个小程序来判断当前机器的字节序

#include <stdio.h>
int main()
{
  int a = 1;
  char* p = (char*)&a;
  if (1 == *p)
  {
    printf("小端\n");
  }
  else
  {
    printf("大端\n");
  }
  return 0;
}
#include <stdio.h>
int main()
{
  int a = 1;
  if (1 == *(char*)&a)
  {
    printf("小端\n");
  }
  else
  {
    printf("大端\n");
  }
  return 0;
}
#include <stdio.h>
int check_sys()
{
  int a = 1;
  if (1 == *(char*)&a)
  {
    return 1;
  }
  else
  {
    return 0;
  }
}
int main()
{
  int ret = check_sys();
  if (1 == ret)
  {
    printf("小端\n");
  }
  else
  {
    printf("大端\n");
  }
  return 0;
}
#include <stdio.h>
//小端返回1
//大端返回0
int check_sys()
{
  int a = 1;
  return *(char*)&a;
}
int main()
{
  int ret = check_sys();
  if (1 == ret)
  {
    printf("小端\n");
  }
  else
  {
    printf("大端\n");
  }
  return 0;
}

2.3 练习


#include <stdio.h>
int main()
{
  char a = -1;
  //100000000000000000000001
  //111111111111111111111110
  //111111111111111111111111 - 截断
  //11111111 - a
  //111111111111111111111111
  //111111111111111111111110
  //100000000000000000000001 --> -1
  signed char b = -1;
  //111111111111111111111111
  //11111111 - b
  unsigned char c = -1;
  //11111111 - c
  //000000000000000011111111 - 补码
  //000000000000000011111111
  //000000000000000011111111 - 原码
  printf("a=%d,b=%d,c=%d", a, b, c);//a=-1,b=-1,c=255
  //%d - 十进制的形式打印有符号整型整数
  //整型提升
  return 0;
}
#include <stdio.h>
int main()
{
  char a = -128;
  //-128
  //10000000000000000000000010000000
  //11111111111111111111111101111111
  //11111111111111111111111110000000 - -128的补码
  //10000000 - a中存的
  //11111111111111111111111110000000 - 整型提升后的补码
  //11111111111111111111111110000000
  //11111111111111111111111110000000 - 原码
  printf("%u\n", a);//4294967168
  
  return 0;
}
#include <stdio.h>
int main()
{
  char a = 128;
  //00000000000000000000000010000000
  //00000000000000000000000010000000
  //00000000000000000000000010000000
  //10000000 - a中存的
  //11111111111111111111111110000000 - 整型提升后的补码
  //11111111111111111111111110000000
  //11111111111111111111111110000000 - 原码
  printf("%u\n", a);//4294967168
  
  return 0;
}
#include <stdio.h>
int main()
{
  int i = -20;
  //10000000000000000000000000010100
  //11111111111111111111111111101011
  //11111111111111111111111111101100
  unsigned int j = 10;
  //00000000000000000000000000001010
  printf("%d\n", i + j);//-10
  //按照补码的形式进行运算,最后格式化成为有符号整数
  //11111111111111111111111111110110
  //11111111111111111111111111110101
  //10000000000000000000000000001010
  //11111111111111111111111111110110
  //10000000000000000000000000001001
  //10000000000000000000000000001010
  return 0;
}
//原码 --> 先取反,再加1 --> 补码
//补码 --> 先减1,再取反 --> 原码
//补码 --> 先取反,再加1 --> 原码
#include <stdio.h>
#include <windows.h>
int main()
{
  unsigned int i;//无符号数恒大于0
  
  for (i = 9; i >= 0; i--)
  {
    printf("%u\n", i);//死循环 9 8 7 6 5 4 3 2 1 0 4294967295 4294967294 ...
    Sleep(1000);//单位是毫秒
  }
  return 0;
}
#include <stdio.h>
#include <string.h>
int main()
{
  char a[1000];//char -128~127
  int i;
  
  for (i = 0; i < 1000; i++)
  {
    a[i] = -1 - i;//-1 -2 -3 ... -128 127 126 ... 2 1 0 -1 -2 ... -128 127 126 ... 2 1 0 ...
  }
  
  printf("%d", strlen(a));//strlen是求字符串长度的,统计的是\0之前出现的字符的个数;\0的ASCII码值是0
  //255
  
  return 0;
}
#include <stdio.h>
unsigned char i = 0;//0~255
int main()
{
  
  for (i = 0; i <= 255; i++)//i <= 255 恒成立
  {
    printf("hello world\n");//死循环打印hello world
  }
  
  return 0;
}


目录
相关文章
|
10天前
|
存储 缓存 中间件
|
5天前
|
存储 Java 程序员
Java面试题:方法区在JVM中存储什么内容?它与堆内存有何不同?
Java面试题:方法区在JVM中存储什么内容?它与堆内存有何不同?
26 10
|
1天前
|
存储 分布式计算 Hadoop
HadoopCPU、内存、存储限制
【7月更文挑战第13天】
24 14
|
5天前
|
存储 设计模式 监控
Java面试题:如何在不牺牲性能的前提下,实现一个线程安全的单例模式?如何在生产者-消费者模式中平衡生产和消费的速度?Java内存模型规定了变量在内存中的存储和线程间的交互规则
Java面试题:如何在不牺牲性能的前提下,实现一个线程安全的单例模式?如何在生产者-消费者模式中平衡生产和消费的速度?Java内存模型规定了变量在内存中的存储和线程间的交互规则
15 0
|
5天前
|
存储 安全 Java
Java面试题:如何在Java应用中实现有效的内存优化?在多线程环境下,如何确保数据的线程安全?如何设计并实现一个基于ExecutorService的任务处理流程?
Java面试题:如何在Java应用中实现有效的内存优化?在多线程环境下,如何确保数据的线程安全?如何设计并实现一个基于ExecutorService的任务处理流程?
10 0
|
5天前
|
安全 Java 调度
Java面试题:Java内存优化、多线程安全与并发框架实战,如何在Java应用中实现内存优化?在多线程环境下,如何保证数据的线程安全?使用Java并发工具包中的哪些工具可以帮助解决并发问题?
Java面试题:Java内存优化、多线程安全与并发框架实战,如何在Java应用中实现内存优化?在多线程环境下,如何保证数据的线程安全?使用Java并发工具包中的哪些工具可以帮助解决并发问题?
7 0
|
5天前
|
安全 算法 编译器
C++一分钟之-内存模型与数据竞争
【7月更文挑战第10天】了解C++11内存模型对多线程编程至关重要。它定义了线程间同步规则,包括顺序一致性、原子操作和内存屏障。数据竞争可能导致不确定行为,如脏读和丢失更新。可通过互斥量、原子操作和无锁编程避免竞争。示例展示了`std::mutex`和`std::atomic`的使用。掌握内存模型规则,有效防止数据竞争,确保多线程安全和性能。
13 0
|
14天前
|
存储
|
29天前
|
消息中间件 存储 Kafka
实时计算 Flink版产品使用问题之 从Kafka读取数据,并与两个仅在任务启动时读取一次的维度表进行内连接(inner join)时,如果没有匹配到的数据会被直接丢弃还是会被存储在内存中
实时计算Flink版作为一种强大的流处理和批处理统一的计算框架,广泛应用于各种需要实时数据处理和分析的场景。实时计算Flink版通常结合SQL接口、DataStream API、以及与上下游数据源和存储系统的丰富连接器,提供了一套全面的解决方案,以应对各种实时计算需求。其低延迟、高吞吐、容错性强的特点,使其成为众多企业和组织实时数据处理首选的技术平台。以下是实时计算Flink版的一些典型使用合集。