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

深度学习数据在内存中的存储

  • 一、数据类型分类
    • 1.1 整型家族(可声明头文件limits.h查看表示范围):
    • 1.2 浮点型家族(可声明头文件float.h查看表示范围):
    • 1.3 构造类型(自定义类型):
    • 1.4 指针类型:
    • 1.5 空类型:
  • 二、整型在内存中的存储
    • 2.1 原码、反码、补码
    • 2.2 大小端介绍
  • 三、浮点型在内存中的存储
    • 3.1 浮点数
    • 3.2 浮点数的存储规则
      • 3.2.1 详细解读
      • 3.2.2 浮点数的存取(IEEE 754规定)
      • 剖析案例

目录·:
我们在这篇博文(第二节第1个内容: 关键字详解)已经介绍了数据类型,为了更加深刻去理解数据类型,我写了这篇博客。相信大家看完这篇文章,肯定会对数据有更深层次的理解。

一、数据类型分类

1.1 整型家族(可声明头文件limits.h查看表示范围):

char(字符型,字符存储的时候是ASCII码值,是整型,所以归类的时候放在整型家族里):
unsigned char(无符号字符型)
signed char(有符号字符型)
short(短整型):
unsigned short [int]
signed short [int]
int(整型):
unsigned intt
signed int
long(长整型):
unsigned long [int]
signed long [int]

1.2 浮点型家族(可声明头文件float.h查看表示范围):

float(单精度浮点数)
double(双精度浮点数)

1.3 构造类型(自定义类型):

数组类型:
int arr1[10]它的数组类型是 int [10]
结构体类型
枚举类型
联合类型

1.4 指针类型:

int* p
char* p1
float* p2
void* p3

1.5 空类型:

void表示空类型(无类型)
通常应用于函数的返回类型,函数的参数,指针类型。

二、整型在内存中的存储

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

2.1 原码、反码、补码

计算机中的整数数据有三种二进制表示方法,即原码、反码和补码。
三种表示方法都有符号位数值位两部分,符号位为‘0’表示真,符号位为‘1’表示假,且数值为正数时,原、反、补码都相同。
数值为负数时三种表示方法各不相同:

原码
直接将数值按照正负数的形式转换为二进制,就可以得到原码。
反码
将原码的符号位不变,其它位依次按位取反可得到反码。
补码
在反码的基础上+1,就可以得到补码
对于整型来说:数据在内存中存放的是二进制补码

图示:
C语言——数据在内存中的存储_第1张图片

扩展:为什么数值用补码的形式进行存储?
因为在计算机系统中,使用补码,可以使符号位和数值位统一处理;同时,加法和减法也可以统一处理(cpu只有加法器);此外,补码和原码可以相互转换,其运算过程是相同的,不需要额外的硬件电路。(本质上存储的是二进制,但在vs上为了更好的展示,显示的是十六进制)

2.2 大小端介绍

什么是大小端:
1)字节序—以字节为单位,确定存储顺序。
2)

  1. 小端字节序存储:把一个数据的低字节的内容,存放在低地址处,高字节的内容,存放到高地址处。
  2. 大端字节序存储:把一个数据的低字节的内容,存放到高地址处,高字节的内容,存放到低地址处。
    如图:
    C语言——数据在内存中的存储_第2张图片
    为什么有大小端之分?
    在计算机系统中,我们是以字节为单位的,每个地址单元都对应着一个字节, 1个字节为8 bit。 但是在C语中除了8 bit的char型之外,还有16 bit的short型,32 bit的long型(要看具体的编译器),另外, 对于位数大于8位的处理器,例如16位或者32位的处理器,由于寄存器宽度大于1个字节, 那么必然存在着一个如何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。
    例如:一个16bit的short型x,在内存中的地址为0x0010,x 的值为0x1122,那么0x11为高字节,0x22 为低字节。对于大端模式,就将0x11放在低地址中,即0x0010中,0x22 放在高地址中,即0x0011中。小端模式,刚好相反。
    小端模式:我们常用的x86结构是小端模式;ARM,DSP也是小端模式。
    大端模式:KEIL 、C51,有些ARM处理器还可以由硬件来选择是大端模式。
    如何判断当前机器的字节序:
    思路:先取一个整数变量的地址,然后强制类型转换为char*,在解引用,就可以取出内存中低地址的内容。然后判断大小端。
#include
int diagnose()
{
    int m = 1;
    return *(char*)&m;//不管是大端还是小端,强制类型转换都是低地址内容
}
int main()
{
    int n = diagnose();
    if (n == 1)
        printf("小端字节序\n");
    else
        printf("大端字节序\n");
    return 0;
}

案例1:

//输出什么?
#include 
int main()
{
    char a = -1;
    //10000000 00000000 00000000 00000001原码
    //11111111 11111111 11111111 11111110反码
    //11111111 11111111 11111111 11111111补码
    //11111111 截断
    signed char b = -1;
    //10000000 00000000 00000000 00000001原码
   //11111111 11111111 11111111 11111110反码
   //11111111 11111111 11111111 11111111补码
   //11111111 截断
    unsigned char c = -1;
    //10000000 00000000 00000000 00000001原码
   //11111111 11111111 11111111 11111110反码
   //11111111 11111111 11111111 11111111补码
   //11111111 截断
    printf("a=%d,b=%d,c=%d\n", a, b, c);//打印a=-1,b=-1,c=255
    //因为要输出,a,b,c;
    //按原类型的符号位整型提升
    //a:11111111 11111111 11111111 11111111补码
    //10000000 00000000 00000000 00000001原码
    //b:11111111 11111111 11111111 11111111补码
    //10000000 00000000 00000000 00000001原码
    //c:00000000 00000000 00000000 11111111补码
    return 0;
}

可以看出-1先以四个字节的二进制的形式表示,然后进行原、反、补转换,然后截断赋值给变量a,打印的时候,先按照原来的类型的符号位进行整型提升,然后根据打印的格式进行原、反、补转换。
测试:C语言——数据在内存中的存储_第3张图片

案例2:

#include 
int main()
{
    char a = -128;
  //  10000000 00000000 00000000 10000000原码
    //11111111 11111111 11111111 01111111反码
    //11111111 11111111 11111111 10000000补码
    //10000000截断
    printf("%u\n", a);//打印结果4294967168
    //按原符号位整型提升:
    //11111111 11111111 11111111 10000000补码
    //无符号整数打印:
    //11111111 11111111 11111111 10000000补码
    //11111111 11111111 11111111 10000000原码
    return 0;
}

测试:
C语言——数据在内存中的存储_第4张图片

案例3:

#include 
int main()
{
    char a = 128;
    //  00000000 00000000 00000000 10000000原码
    //  00000000 00000000 00000000 10000000补码
      //10000000截断
    printf("%u\n", a);//打印结果4294967168
    //按原符号位整型提升:
    //11111111 11111111 11111111 10000000补码
    //无符号整数打印:
    //11111111 11111111 11111111 10000000补码
    //11111111 11111111 11111111 10000000原码
    return 0;
}

测试:
C语言——数据在内存中的存储_第5张图片
总结:不难看出在打印的时候,按照原类型的符号进行整型提升,然后根据打印的格式进行打印

案例4:

#include 
int main()
{
    int i = -20;
    //10000000 00000000 00000000 00010100原码
    //11111111 11111111 11111111 11101011反码
    //11111111 11111111 11111111 11101100补码
    unsigned int j = 10;
    //00000000 00000000 00000000 00001010原码
    //00000000 00000000 00000000 00001010补码
    printf("%d\n", i + j);//按照补码的形式进行运算,最后格式化成为有符号整数,打印-10
    //11111111 11111111 11111111 11101100补码i
    //00000000 00000000 00000000 00001010补码j
    //11111111 11111111 11111111 11110110i+j补码
    //11111111 11111111 11111111 11110101反码
    //10000000 00000000 00000000 00001010原码
    return 0;
}

测试:
C语言——数据在内存中的存储_第6张图片

案例5:

#include 
#include 
int main()
{
    char a[1000];
    int i = 0;
    for (i = 0; i < 1000; i++)
    {
        a[i] = -1 - i;
    }
    /*/*i为0,1,2,3,4,5,……,9999时
    a[i]的值为-1,-2,-3,-4.…,-127,-128,127,126,……,1,0,-1,-2,直到放进去1000组数值
    */
    printf("%d\n", strlen(a));//strlen计算字符串长度,遇到‘\0’结束,不加'\0',所以打印255
    return 0;
}

测试:
C语言——数据在内存中的存储_第7张图片

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

3.1 浮点数

常见的浮点数:
3.1415
1E10
浮点数家族包括:
float、double、long double
如:
1234.56
可以写成1.23456*10^3
小数点可以浮动,所以叫浮点数

  • 整数的数值在内存中存进去之后,以整型形式和浮点型形式从内存中取出的结果不一样
  • 整型的存,那么就整型的取
  • 浮点型的存,那么就浮点型的取

3.2 浮点数的存储规则

3.2.1 详细解读

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

  • (-1)^S * M *2^E
  • (-1)^S表示符号位,当S=0时,V为正数,当S=1时,V为负数
  • M表示有效数字,大于等于1,小于2
  • 2^E表示指数位

如:
浮点数5.5
V=5.5
二进制形式;101.1
科学计数法:(-1)^0 *1.011 *2 ^2
S=0;M=1.011;E=2

32位的浮点数,最高的1位是符号位S,接着的8位是指数位E,剩下的是有效位M。
C语言——数据在内存中的存储_第8张图片

65位的浮点数,最高的1位是符号位S,接着的11位是指数位E,剩下的是有效位M。

3.2.2 浮点数的存取(IEEE 754规定)

以32位浮点数为例:
1)有效数字M
1≤M<2,也就是说,M可以写成1. xxxxx的形式,其中xxxxx表示小数部分。在计算机内部保存M时,默认这个数的第一位总是1, 因此可以被舍去,只保存后面的xxxxxx部分。等到读取的时候,再把第一位的1加上去。这样做的目的,可以节省1位有效数字。留给M的有23个有效位,将第一位舍去,就可以保存24位有效位
2)指数位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从内存中取出还可以再分成三种情况:

  1. 不全为0或不全为1
    这时,浮点数就采用下面的规则表示,即指数E的计算值减去127(或1023),得到真实值,有效数字M加1.
  2. E全为0
    这时,浮点数的指数E等于1-127 (或者1-1023) 即为真实值,
    有效数字M不再加上第一位的1, 而是还原为0.xxxxxx的小数。这样做是为了表示+0和-0,,以及更接近于0的很小的数字。
  3. E全为1
    这时,有效数字M全为1,表示-无穷大和+无穷大(正负取决于符号位S)。

剖析案例

#include 
int main()
{
    int n = 9;
    float* pfloat = (float*)&n;
    printf("n的值为:%d\n", n);
    printf("*pfloat的值为:%f\n", *pfloat);
    *pfloat = 9.0;
    printf("n的值:%d\n", n);
    printf("&pfloat的值:%f\n", *pfloat);
    return 0;
}

打印的结果:
C语言——数据在内存中的存储_第9张图片
分析:

#include
int main()
{
int n = 9;
//00000000 00000000 00000000 00001001补码
float * pfloat = (float*)&n;
printf(“n的值为:%d\n”, n);
printf(" * pfloat的值为:%f\n", * pfloat);
//S=0,E=00000000,M=00000000000000000001001
// 科学计数法表示
//因为指数E全为0,所以浮点数V就写成:
// (-1) ^0 * 0.00000000 00000000 0001001 * 2 ^( -126)=1.001*2^(-146)无限趋于0的一个数字
*pfloat = 9.0;
//9.0转化为二进制:1001.0,转换为科学计数法形式:(-1) ^ 0 * 1.001 * 2 ^ 3
//其中S=0,M=1.001,E=3
//存入到内存:0 10000010 00100000000000000000000
printf(“n的值:%d\n”, n);
//01000001 00010000 00000000 00000000打印的时候是个非常大的数字
printf(“&pfloat的值:%f\n”, *pfloat);
return 0;
}

你可能感兴趣的:(C语言,c语言,开发语言)