C语言中浮点数和整形数据的储存与读取

1.数据类型介绍

C语言的基本的内置类型有

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

C语言标准规定了一些库函数 规定函数名 参数类型 返回值类型 函数功能
但没有规定这些库函数怎么实现。

库函数的具体实现是编译器的厂商提供的 VS gcc

类型的意义：

1. 使用这个类型开辟的内存空间的大小
2. 看待内存空间的视角。

类型的归类：

整形家族

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