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

目录

1. 数据类型介绍

1.1 类型的基本归类   

        

2. 整形在内存中的存储

2.1 原码、反码、补码

2.2 大小端介绍

         2.3整形提升

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

3.1 浮点数存储规则


1. 数据类型介绍

char        //字符数据类型
short       //短整型
int         //整形
long        //长整型
long long   //更长的整形
float       //单精度浮点数
double      //双精度浮点数

        值得一提的是,C中是没有字符串类型存在的 。

        为什么C中要设置各种各样的数据类型呢,个人认为,它的意义有以下几点。

数据类型的意义

                ①避免浪费内存防止内存不够用。

                ②解决“存”的问题:决定使用此类型需要开辟内存空间大小(大小决定了使用范围)。

                ③解决“取”的问题:改变看内存视角,可以一个类型一个类型的看,而非一个比特位一个比特位的看,即如何看待内存空间的视角

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]

char类型也输入整形家族,因为char类型在存储的时候是以ACISS码进行存储的,也就是说,实际上存储的是数组,所以char类型属于整形家族 

浮点数家族

float
double

 构造类型

> 数组类型
> 结构体类型 struct
> 枚举类型 enum
> 联合类型 union

关于此类构造类型以后我会写博客进行详细的讲解

 指针类型

int *pi;
char *pc;
float* pf;
void* pv;

值得注意的是,不同的指针类型的大小在同一个平台下是相同的,具体为32位平台4个字节,64位平台8个字节,而关于指针类型的意义啥的,我会在之后写一篇关于指针的博客进行讲解

空类型 

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

2. 整形在内存中的存储

        

        一个变量的创建是要在内存中开辟空间的,而具体开辟空间的大小是由变量的类型决定的。

比如我们在创建一些整形变量的时候,

int a = 100;
int b = -100;

我们知道的是,在创建这两个变量的时候会为其分配4个字节的空间,那么,数据在所开辟的内存中是如何储存的呢?在了解这个之前,我们先来学习一下原反补的概念。

2.1 原码、反码、补码

        首先,我们需要了解,在计算机中的整数总共存在三种二进制的表达方式,分别是原码,反码和补码。

        三种表达方式都具有符号位和数值位两部分,对于符号位而言“0”表示的是正数,“1”表示的是负数。

现在,我们开始了解一下原反补码的概念。

原码

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

        栗子:

                

在此,我们以32位机器为例(32位机器的int类型大小为4个字节,即32个比特位)

例如,20的原码是

0000 0000 0000 0000 0000 0000 0001 0100(第一个0是符号位,表示正数)

-20的原码是
1000 0000 0000 0000 0000 0000 0001 0100(第一个1是符号位,表示负数)

反码

        将原码的符号位不变,其他位按位取反就得到了反码。

        栗子:

-20的原码是
1000 0000 0000 0000 0000 0000 0001 0100(第一个1是符号位,表示负数)

由于反码是原码的除符号位的按位取反,所以-20的补码是

1111 1111 1111 1111 1111 1111 1110 1011(第一个1是符号位,表示负数)

补码

        反码+1,得到的就是补码。

        栗子:

-20的原码是
1000 0000 0000 0000 0000 0000 0001 0100(第一个1是符号位,表示负数)

由于反码是原码的除符号位的按位取反,所以-20的补码是

1111 1111 1111 1111 1111 1111 1110 1011(第一个1是符号位,表示负数)


补码是反码+1
所以-20的补码就是

1111 1111 1111 1111 1111 1111 1110 1100(第一个1是符号位,表示负数)

然后再来注意正负数。

正数

        正数的原反补都相同。

负数

        负数在原反补上的存储与正数截然不同。
       

值得注意的是,对于整形来说,在内存中存的是补码

为啥呢?

        

 现在我们不妨在VS里调试一下看看

        

通过这里,我们不难发现内存中存储的确实是补码,但是,他的存储顺序好像有点问题,这又是为什么呢?

2.2 大小端介绍

首先,什么是大小端

那为什么会出现大小端这种东西呢?

 Ok,下面我们进行一个小插曲,写一个可以判别当前机器是大端还是小端的代码

#include <stdio.h>
int check_sys()
{
 int i = 1;
 return (*(char *)&i);//char类型的指针会取低地址的第一个字节
                      //所以只需要判断取出的字节是0还是1就好了
}
int main()
{
 int ret = check_sys();
 if(ret == 1)
 {
 printf("小端\n");
 }
 else
 {
 printf("大端\n");
 }
 return 0;
}

2.3整形提升

首先,什么是整型提升?
整型提升是C程序设计语言中的一项规定:在表达式计算时,各种整形首先要提升为int类型。表达式的整型运算要在CPU的相应运算器件内执行,CPU内的整型运算器的操作数的字节长度一般是int 类型的字节长度,即四个字节。

所以说,如果是两个char类型的数据相加的话,需要先将其整形提升为整形之后在进行计算。

下面,我们对整形提升进行详细的讲解。

首先,要了解一下整形提升的规则。

整型提升的规则:
        整型提升分为有符号和无符号两种。

        1.有符号的:整型提升时是按照变量的补码被截断时的最高位是什么进行补位的,如果截断后最高位即最左面的一位数为 1 则在最高位前补 1 ,如果最高位是 0 则在前面补 0 ,补够32位即int类型即可。

        2.无符号的: 直接在被截断的前面补 0 即可。

举几个栗子:

char a = -1;
printf("%d",a);
//1000 0000 0000 0000 0000 0000 0000 0001 原码
//1111 1111 1111 1111 1111 1111 1111 1110 反码
//1111 1111 1111 1111 1111 1111 1111 1111 补码
//1111 1111 截断
//整形提升
//1111 1111 1111 1111 1111 1111 1111 1111 补码
//1111 1111 1111 1111 1111 1111 1111 1110 反码
//1000 0000 0000 0000 0000 0000 0000 0001 补码

所以上述代码最终打印的是 -1。

char a = 130;
printf("%d",a);
//0000 0000 0000 0000 0000 0000 1000 0010 原码
//0000 0000 0000 0000 0000 0000 1000 0010 原码
//0000 0000 0000 0000 0000 0000 1000 0010 原码
//1000 0010 截断
//整形提升
//1111 1111 1111 1111 1111 1111 1000 0010 补码
//1111 1111 1111 1111 1111 1111 1000 0001 反码
//1000 0000 0000 0000 0000 0000 0111 1110 补码 -126

由上述过程可知,最终打印的值为-126。

	unsigned char c = 130;
	//0000 0000 0000 0000 0000 0000 1000 0010原
	//0000 0000 0000 0000 0000 0000 1000 0010反
	//0000 0000 0000 0000 0000 0000 1000 0010补
	//1000 0010截断
	//整形提升
	//0000 0000 0000 0000 0000 0000 1000 0010原
	//0000 0000 0000 0000 0000 0000 1000 0010反
	//0000 0000 0000 0000 0000 0000 1000 0010补 130
	unsigned char d = -10;
	//1000 0000 0000 0000 0000 0000 0000 0010原
	//1111 1111 1111 1111 1111 1111 1111 1101反
	//1111 1111 1111 1111 1111 1111 1111 1110补
	//1111 1110截断
	//整形提升
	//0000 0000 0000 0000 0000 0000 1111 1110原
	//0000 0000 0000 0000 0000 0000 1111 1110反
	//0000 0000 0000 0000 0000 0000 1111 1110补 246
	printf("%d\n%d\n", c, d);

所以最终输出的答案是 130 和 246。

小练习(判断以下代码输出的结果)答案在文章末尾

// 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;
}
//2.
#include <stdio.h>
int main()
{
    char a = -128;
    printf("%u\n",a);
    return 0;
}
//3.
#include <stdio.h>
int main()
{
    char a = 128;
    printf("%u\n",a);
    return 0;
}
//4.
int i= -20;
unsigned  int  j = 10;
printf("%d\n", i+j);
//5.
unsigned int i;
for(i = 9; i >= 0; i--)
{
    printf("%u\n",i);
}
//6.
int main()
{
    char a[1000];
    int i;
    for(i=0; i<1000; i++)
   {
        a[i] = -1-i;
   }
    printf("%d",strlen(a));
    return 0;
}
//7.
#include <stdio.h>
unsigned char i = 0;
int main()
{
    for(i = 0;i<=255;i++)
   {
        printf("hello world\n");
   }
    return 0;
}

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

对于浮点数的存储,我们以一个程序为栗子展开讲解。

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

这是为啥呢,让我们先来看一下浮点数的存储规则 。

3.1 浮点数存储规则

首先,我们需要知道
        根据国际标准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
IEEE 754 规定:
对于 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 全为 0
E 全为 1
下面,让我们回到一开始的问题:为什么 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 是一个很小的接近于 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
ok写完了,跑路跑路,学校作业还没整完呢

答案(题解看我的另一篇博客)(链接http://t.csdn.cn/xfuEO
1.a=-1,b=-1,c=255
2.4294967168
3.4294967168
4.-10
5.无限循环打印i
6.255
7.死循环打印hello world
  • 17
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 12
    评论
评论 12
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值