数据类型与内存存储：整型、浮点型、大小端解析-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_62513305/article/details/122672805

数据的类型

基本的内置类型
char	字符数据类型
short	短整型
int	整型
long	长整型
long long	长长整型
float	浮点型
double	双精度浮点数

整型家族
char	unsigned char
	signed char
short	unsigned short [int]
	signed short [int]
int	unsigned int
	signed int
long	unsigned long [int]
	signed long [int]

浮点数家族
float
double

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

指针类型
int *pi;
char *pc;
float *pf;
void *pv;

空类型
void表示空类型，（无类型）

整型在内存中的存储

整型在内存中存放的是补码。

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

有符号的数最高位是符号位。

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

负数：

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

反码：将原码的符号位不变，其他位一次按位取反就可以得到了。

补码：反码加1得到补码。

大小端

大端存储模式：数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址中。

小端存储模式：数据的低位保存在内存的低地址中，而数据的高位，保存在内存的高地址中。

为什么有大小端：

在计算机系统中，我们以字节为单位的，每个地址单元都对应着一个字节，一个字节为8 bit。但是在c语言中，除了8bit的char之外，还有16bit的short型，32bit的long型，另外，对于位数大于8位的处理器，例如16位或32位的处理器，由于寄存器宽度大于一个字节，那们必然存在着一个如何将多个字节安排的问题。因此导致了大端模式和小端模式

#include <stdio.h>

int check_sys()
{
	union
	{
		int i;
		char c;
	}Un;
	Un.i = 1;
	return Un.c;
}

int main()
{
	int res = check_sys();
	if (res == 1) {
		printf("小端\n");
	} else {
		printf("大端\n");
	}
	return 0;
}

#include <stdio.h>

int main()
{
	int a = -5;
	// 原码 10000000 00000000 00000000 00000101 
	// 反码 11111111 11111111 11111111 11111010
	// 补码 11111111 11111111 11111111 11111011
	//      ff         ff       ff      fb
	// 0xfffffffb----fb ff ff ff
	int b = -10;
	// 原码 10000000 00000000 00000000 00001010
	// 反码 11111111 11111111 11111111 11110101
	// 补码 11111111 11111111 11111111 11110110
	//      ff      ff        ff         f6
	// 0xfffffffa --- f6 ff ff ff
	return 0;
}

#include <stdio.h>
int main()
{
	char a = -1;
	signed char b = -1;
	unsigned char c = -1;
	// -1
	// 原码：10000001 
	// 反码：11111110 
	// 补码：11111111 无符号时,2 ^ 8 - 1 = 255 
	printf("a=%d,b=%d,c=%d", a, b, c);//-1,-1,255
	return 0;
}

#include <stdio.h>
int main()
{
	char a = -128;
	printf("%u\n", a);
	// %u 以无符号的形式打印
	// 10000000 00000000 00000000 10000000
	// 11111111 11111111 11111111 01111111
	// 11111111 11111111 11111111 10000000 = 4294967168
	return 0;
}

#include <stdio.h>
int main()
{
	char a = 128;
	printf("%u\n", a);
	// 00000000 00000000 00000000 10000000 // 128补码
	// 11111111 11111111 11111111 10000000 // 整型提升之后，补充符号位
	return 0;
}

#include <stdio.h>

int main()
{
	int i = -20;
	unsigned int j = 10;
	printf("%d\n", i + j);// -10
	// -20
	// 10000000 00000000 00000000 00010100
	// 11111111 11111111 11111111 11101011
	// 11111111 11111111 11111111 11101100   -20补码
	// 00000000 00000000 00000000 00001010    10补码
	// 11111111 11111111 11111111 11110110    -20 + 10 的补码
	// 10000000 00000000 00000000 00001001
	// 10000000 00000000 00000000 00001010    -20 + 10 的结果
	return 0;
}

#include <stdio.h>

int main()
{
	unsigned int i;
	for (i = 9; i >= 0; i--)
	{
		printf("%u\n", i);
	}
	// 陷入的死循环
	// i 是无符号的数，0 -1 是一个正数
	return 0;
}

#include <stdio.h>
#include <string.h>

int main()
{
	char a[1000];
	int i;
	for (i = 0; i < 1000; i++)
	{
		a[i] = -1 - i;
	}
	printf("%d", strlen(a));// 255
	// char : -128 ~ 127
	// -1, -2, -3, ..., -128, 127, 126, ... , 0 ...
	// '\0' 是结束标志，-1 ~ -128, 127 ~ 1; 128 + 127 = 255 
	// char 补码
	// 正数
	// 00000000    0
	// 00000001    1
	// 00000002    2
	// 00000003    3
	// 00000004    4
	// ....
	// 01111111    127
	// 负数
	// 10000000    -128 // 规定
	// 10000001    -127
	// 10000001    -126
	// ...
	// 11111111    -1
	// 在有符号的类型中，char ： 127 + 1 = -128； short ： -32768 ~ 32767  32767 + 1 = -32768
	return 0;
}

#include <stdio.h>
unsigned char i = 0;
int main()
{
	for (i = 0; i <= 255; i++)
	{
		printf("hello world\n");
	}
	// 死循环，
	// i是无符号的char， 255 + 1 = 0， 
	return 0;
}

浮点型在内存中的存储

浮点数的存储规则：

根据国际标准 IEEE754，任意一个二进制浮点数V可以表示成下面的形式：

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

IEEE 754规定：

对于32位的浮点数，最高的一位是符号位S，接着8位是指数E，剩下23位为有效数字M。

对于64为的浮点数，最高的一位是符号位S，接着11位是指数E，剩下的52位为有效数字M。

IEEE 754 对有效数字M和指数E，还有一些特别规定：

M可以写成1.xxxxxx的形式，其中xxxxxx表示小数部分。

在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的xxxxxx部分。比如1.01只保存01，等到读取的时候，再把第一位的1加上去。这样做的目的是省略一位有效数字。以32位浮点数为列，留给M的只有23位，将第一位的1省去后，等于可以保存24位有效数字。

如果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的计算值减去127或1023，得到真实值，再将有效数字M前加上第一位的1。0.5的二进制表达形式：0 01111110 00000000000000000000000

E全为0时：

浮点数的指数E等于1 - 127（或者1 - 1023）即为真实值，有效数字M不再加上第一位的1，而是还原为0.xxxxxxx的小数。这样做是为了表示±0，以及接近于0的很小数字。

E全为1时：

这时，如果有效数字M全为0，表示±无穷大。

#include <stdio.h>

int main()
{
	int n = 9;
	float* pFloat = (float*)&n;
	printf("n的值为：%d\n", n);             // 9
	//n 是整型，以十进制的形式打印，是9
	printf("*pFloat的值为：%f\n", *pFloat); // 0.000000
	// 9:
	// 0 00000000 00000000000000000001001
	// S     E              M
	// (-1) ^ S * M * 2 ^ E
	// S = 0;
	// E 全为0时，E： 1 - 127 = -126
	// M 0.00000000000000000001001
	// (-1) ^ 0 * (0.00000000000000000001001) * 2 ^ (-126) ≈ 0，接近于0的很小的数字
	*pFloat = 9.0;
	printf("num的值为：%d\n", n);           // 1091567616	
	// 9.0 = 1001.0 = (-1)^ 0 * 1.0010 * 2 ^ 3 
	// S = 0, E = 3 (+ 127)  (130) , M = 0010 
	// 0 10000010 00100000000000000000000 =     1091567616
	printf("*pFloat的值为：%f\n", *pFloat); // 9.000000
	// *pFloat 是float类型的指针，且赋给一个浮点数，所以打印出来的是浮点值
	return 0;
}