深度剖析数据在内存中的存储
1.数据类型介绍
C语言的基本的内置类型有
char //字符数据类型
short //短整型
int //整形
long //长整型
long long //更长的整形
float //单精度浮点数
double //双精度浮点数
C语言标准规定了一些库函数 规定函数名 参数类型 返回值类型 函数功能
但没有规定这些库函数怎么实现。
库函数的具体实现是编译器的厂商提供的 VS gcc
类型的意义：
- 使用这个类型开辟的内存空间的大小
- 看待内存空间的视角。
类型的归类：
整形家族
char
unsigned char 0~255
signed char -128~127
short
unsigned short[int] 0~65535
signed short[int] -32768~32767
int
unsigned int 0~2^32-1
signed int -2^31~2^31-1
long
unsigned long 0~2^32-1
signed long -2^31~2^31-1
long long
unsigned long long 0~2^64-1
signed long long -2^63~2^63-1
//直接写
char a;
//有无符号取决于编译器 C语言标准没有规定
//大部分的编译器都当做有符号的char
//short int long 默认是有符号的 C语言标准明确规定的
signed 和 unsigned 的区别
int main()
{
unsigned char c1=255;
char c2=255;
printf("%d\n",c1);
printf("%d",c2);
return 0;
}
//打印结果是255 -1
//因为255以二进制放在内存是 1111 1111
//unsigned没有符号位和原反补的概念 是多少打印多少 255
//signed最高位是符号位 当储存的是负数的时候 会认为我们储存的是补码
//然后解回原码 1111 1111-0000 0001=1111 1110
//取反 1000 0001就是-1
浮点型家族
float
double
构造类型
数组类型 int [10]
结构体类型 struct
枚举类型 enum
联合类型 union
指针类型
int* char* int(*)[10] int(*)(int,int)
空类型
void
阻止函数传参数(void)
2.整形在内存中的存储
int main()
{
int a=-1;
return 0;
}
//单步调试看内存发现a在内存中存储的是ffffffff
这就引出了原码 反码 补码
2.1 原码、反码、补码
计算机中的整数有三种表达方式，即原码、反码和补码
三种表达方式均有符号位和数值位两部分，符号位都是用0表示正，用1表示负，而数值位负整数的三种表达方式各不相同。
对于正整数来说，原码 反码 补码完全相同
对于负整数:
-
原码 直接将数按照二进制的形式转化 注意符号位
-
反码 符号位不变 其他位变
-
补码 反码+1得到补码。
对于整形来说：数据存放内存中其实存放的是补码。
为什么在内存中要存补码呢？
1+(-1)假设用原码计算
00000000 00000000 00000000 00000001
10000000 00000000 00000000 00000001
10000000 00000000 00000000 00000010 -2？
假设用补码运算
00000000 00000000 00000000 00000001
11111111 11111111 11111111 11111111
1 00000000 00000000 00000000 00000000 溢出了 只保留
00000000 00000000 00000000 00000000
我们还同时进行了符号位的运算
在计算机系统中，数值一律用补码来表示和存储。
-
原因在于，使用补码，可以将符号位和数值域 统一处理；
-
同时，加法和减法也可以统一处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程 是相同的，不需要额外的硬件电路。
对于补码 先保持符号位不变其他位按位取反，然后加1也可以得到原码。
原码得到反码，反码得到原码规则是一模一样的。
数据放在内存中的顺序(以字节为单位)
0x11223344
44 33 22 11—小端字节序
11 22 33 44—大端字节序
2.2大小端介绍
-
大端字节序存储，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地 址中；
-
小端字节序存储，是指数据的低位保存在内存的低地址中，而数据的高位,，保存在内存的高地 址中。
判断方法:
#include <stdio.h>
int check_sys()
{
int a = 1;
return *(char*)(&a);
}
int main()
{
int ret = check_sys();
if (ret == 1)
{
printf("小端\n");
}
else
{
printf("大端\n");
}
return 0;
}
2.3 练习
//输出什么？
#include <stdio.h>
int main()
{
//-1
//11111111 11111111 11111111 11111111
//char不够4个字节 截断
//11111111
char a= -1;
signed char b=-1;
unsigned char c=-1;
//%d以有符号整形打印
//有符号数整形提升高位补符号位
//无符号数整形提升高位补0
printf("a=%d,b=%d,c=%d",a,b,c);
//a整形提升 11111111 11111111 11111111 11111111
//c整形提升 00000000 00000000 00000000 11111111
//a -1 b -1 c 255
return 0;
}
2.
#include <stdio.h>
int main()
{
char a = -128;
//-128是个int 其存储形式：
//10000000 00000000 00000000 10000000
//char截断
//10000000
//要以%u打印 打印整数得整形提升
//char是有符号的 认为1是符号位 提升
//11111111 11111111 11111111 10000000
//%u 以无符号打印 所以就是
//4294967168
printf("%u\n",a);
return 0;
}
#include <stdio.h>
int main()
{
char a = 128;
//00000000 00000000 00000000 10000000
//10000000
//11111111 11111111 11111111 10000000
printf("%u\n", a);
return 0;
}
4.
int i= -20;
//10000000 00000000 00000000 00010100
//11111111 11111111 11111111 11101011
//11111111 11111111 11111111 11101100
unsigned int j = 10;
//00000000 00000000 00000000 00001010
printf("%d\n", i+j);
//11111111 11111111 11111111 11110110
//10000000 00000000 00000000 00001001
//10000000 00000000 00000000 00001010
//-10
//按照补码的形式进行运算，最后格式化成为有符号整数
5.
unsigned int i;
for(i = 9; i >= 0; i--)
{
printf("%u\n",i);
}
//会死循环 9 8 7 6 5 4 3 2 1 0
//然后再减会变成-1 但是是那种%d视角下的-1 %u视角下是一个超大的数
//无符号数字i会变成一个很大的数 然后一直大于等于0 一直循环
%d 把内存视为有符号数打印
%u 把内存视为无符号数打印
6.
int main()
{
char a[1000];
int i;
for(i=0; i<1000; i++)
{
a[i] = -1-i;
// -256 10000000 00000000 00000001 00000000
// 11111111 11111111 11111110 11111111
// 11111111 11111111 11111111 00000000
//i=255 循环了256次
}
//用char的整数环来看 -1就是反着转
//-1 -2 ...-128 127 126.....0 一共走了256步
//最后一个是\0不算 长度为255
printf("%d",strlen(a));
//255
return 0;
}
或者以这个环的视角看，逆时针转代表减法，一开始在-1，到0一共赋了256次值，但是\0不算长度，所以长度是255。
#include <stdio.h>
unsigned char i = 0;
int main()
{
for(i = 0;i<=255;i++)
{
printf("hello world\n");
}
return 0;
}
//无限循环
无符号数做循环条件很危险。
3.浮点型在内存中的存储形式
1E10 1*10^10
常见的浮点数： 3.14159 1E10
浮点数家族包括： float、double、long double 类型。
浮点数表示的范围：float.h中定义
整形的表示范围在limits.h中定义
INT_MAX
//右键转到定义就可以看到
3.1 一个例子
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.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.5 101.1//后面的位次是2^-1 2^-2 .......
//所以它可以写成
(-1)^0*1.011*2^2
区域E是存的和E有关的一个值 趋于M存的是一个和M有关的值
有关M的存储方式：
- 1≤M<2 ，也就是说，M可以写成 1.xxxxxx 的形式，其中xxxxxx表示小数部分。
- IEEE 754规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的 xxxxxx部分。比如保存1.01的时候，只保存01（后面补0），等到读取的时候，再把第一位的1加上去。
- 这样做的目 的，是节省1位有效数字。以32位浮点数为例，留给M只有23位，将第一位的1舍去以后，等于可以保存24位有效数字（包括1）。
有关E的存储方式:
首先，E为一个无符号整数（unsigned int） 这意味着，如果E为8位，它的取值范围为0255；如果E为11位，它的取值范围为02047。
但是，我们知道，科学计数法中的E是可以出现负数的，所以IEEE 754规定，存入内存时E的真实值必须再加上一个中间数， 对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。比如，2^10的E是10，所以保存 成32位浮点数时，必须保存成10+127=137，即10001001。
#include <stdio.h>
int main()
{
float f = 5.5;
//5.5=101.1=(-1)^0*1.011*2^2 0000 0010
// 127=0111 1111 2+127=1000 0001
//0 10000001 01100000000000000000000
//0100 0000 1011 0000 0000 0000 0000 0000
//40 B0 00 00
//如果小端存储 应该是00 00 B0 40
return 0;
}
浮点数的存放也存在大小端
浮点数的读取方式：
sp1. E不是全0也不是全1，
??这时，只需要让E减去127(double为1023)得到原本的E，然后以(-1)^S*1.M *2^E即可。
比如40 B0 00 00 10000001-127=10000001-01111111=0000 0010=2
所以为(-1)^0*1.011 *2^2=5.5
sp2. E是全0
??我们稍加分析一下这种情况，什么时候会加127然后还全0，显然是原本是-127，那么稍加思考可以明白这个数非常非常非常小，所以我们这时候直接有个规定:
??浮点数的指数E等于1-127（或者1-1023）即为真实值， 有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于0的很小的数字。
sp3. E全是1
??分析同上，发现这是一个非常大的数，所以我们直接结合符号位确定为±无穷大。
所以我们就可以来解释那个例子了
#include <stdio.h>
int main()
{
int n = 9;
//00000000 00000000 00000000 00001001
float* pFloat = (float*)&n;
//以浮点数的视角
//S=0;存放E的地方全零 E=1-127=-126
//0.0000000 00000000 00001001*2^-126
//以%f打印时 默认打印小数点6位 0.000000
printf("n的值为：%d\n", n);
printf("*pFloat的值为：%f\n", *pFloat);
*pFloat = 9.0;
//9.0=1001.0=1.001*2^3
//S=0 M=00100000000000000000000
//E=3 00000011加127等于10000010
//0 10000010 00100000000000000000000
//0100 0001 0001 0000 0000 0000 0000 0000
//1*2^30+1*2^24+1*2^20=1091567616
printf("num的值为：%d\n", n);
printf("*pFloat的值为：%f\n", *pFloat);
return 0;
}