一、数据类型介绍
char //字符数据类型
short //短整型
int //整形
long //长整型
long long //更长的整形
float //单精度浮点数
double //双精度浮点数
类型的基本归类
整形：
char
unsigned char
signed char
short
unsigned short
signed short
int
unsigned int
signed int
long
unsigned long
signed long
- unsigned表示无符号，signed表示有符号
- 平常写代码时：int a、short a、long a就等价于signed int a、signed short a、signed long a，但是char并不等价与signed char，它是signed char还是unsigned char取决于编译器
- char是整形是因为字符在内存中存储的是字符的ASCII码值，而ASCII码值是整形，所以字符类型归类到整形
浮点型：
float
double
构造类型：
数组类型
结构体类型 struct枚举类型 enum
联合类型 union
枚举类型和联合类型我们之后会进行讲解
指针类型：
int* p
char* p
float* p
void* p
void* p意思是指针p所指向的类型不确定
空类型：
void表示空类型
通常应用于函数的返回类型、函数的参数、指针类型。
二、整形在内存中的存储
我们知道一个变量的创建是要在内存中开辟空间的。空间的大小是根据不同的类型而决定的。那接下来我们再深入的研究数据在所开辟内存中到底是如何存储的
举个例子：
int a = 20; //在内存中开辟了4个字节的空间，那它是如何存储的呢？
1. 原码、反码、补码
在之前的“操作符重点讲解”中讲过，这里我们再讲一遍：
整数的二进制表示形式有3种：原码、反码、补码
原码：按照数值的正负，直接写出的二进制序列就是原码
反码：原码的符号位（最左边的数）不变，其他位数取反（0变1，1变0）
补码：反码的二进制+1就得到补码
整数在内存中都是以补码的形式存储的
一个整数写出二进制序列的时候，就是32个bit位（因为是4个字节，1个字节为8个bit）
对于有符号整数来说，最高位（最左边的数）就是符号位
符号位是1表示负数
符号位是0表示正数
对于正整数：原码、反码、补码相同
对于负整数：反码和补码是需要计算的
对于无符号整数来说，没有符号位，所有位都是有效位
无符号整数的原码、反码、补码相同
下面举个例子：
10
原码：00000000000000000000000000001010
反码：00000000000000000000000000001010
补码：00000000000000000000000000001010
1010是10的二进制形式，因为整数占32个bit位且10为正数，所以原码前面全部补0
-10
原码：10000000000000000000000000001010
反码：11111111111111111111111111110101
补码：11111111111111111111111111110110
-10为负数，其原码最高位也就是最左边的数为1，其他的补0
在调试的内存窗口中地址和内存都是以十六进制的形式表示的（因为在计算机内部,二进制数据转换为十六进制数据最直接、最快捷,占用存储空间最小，且十六进制比较简短），每4个二进制位代表1个十六进制位，最后一个1010转为十进制为10，再转为十六进制就是a。
我们还可以发现数据是倒着存放的，接下来我们介绍一下大小端
2. 大小端介绍
概念：
大端（存储）模式：是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的 低地址中
小端（存储）模式：是指数据的低位保存在内存的低地址中，而数据的高位，保存在内存的 高地址中
具体是大端还是小端取决于编译器
而我们之前的例子就是小端存储模式（VS2022）
3. 例题
//1
signed char b = -1;
unsigned char c = -1;
printf("b=%d,c=%d", b, c);b为有符号，所以将-1赋值给b，其打印结果也为-1；重点是c
unsigned char c = -1;
//原码：10000000000000000000000000000001
//反码：11111111111111111111111111111110
//补码：11111111111111111111111111111111
//因为字符类型占1个字节，8个bit位，所以存储到c中的补码为：11111111
printf("%d", c);
//在printf函数中将c按照int形式打印出来，所以应进行整型提升
//而无符号整型提升高位补0
//整型提升：00000000000000000000000011111111
//%d是以10进制的形式，打印有符号的整数，也就是说它将上面整型提升后的数视为
//有符号的数，上面的数转换为10进制后为255
//2
char a = -128;
printf("%u\n", a);
//%u是以10进制的形式，打印无符号的整数
讲解：
//char a = -128;
//原码：10000000000000000000000010000000
//反码：11111111111111111111111101111111
//补码：11111111111111111111111110000000
//存储到a中：10000000
//a为有符号，所以整型提升时高位补符号位的数
//整型提升：11111111111111111111111110000000
printf("%u", a);
//%u将a视为无符号数，因此整形提升后的二进制数
//全为有效位，将其转换为10进制后为 4294967168 ，是很大一个数//3
int i = -20;
unsigned int j = 10;
printf("%d\n", i + j);讲解：
//int i = -20;
//原码：10000000000000000000000000010100
//反码：11111111111111111111111111101011
//补码：11111111111111111111111111101100
//unsigned j = 10;
//原码/反码/补码：00000000000000000000000000001010
补码相加后的结果转为原码再转为10进制就是最终结果
//11111111111111111111111111110110
//10000000000000000000000000001010 ----原码
// -10 ----十进制
//printf("%d", i + j);//4
unsigned int i;
for (i = 9; i >= 0; i--)
{
printf("%u\n", i);
}
讲解：
unsigned int i;
//由于无符号的数始终大于等于0
//所以会无限循环下去
for (i = 9; i >= 0; i--)
{
当i = -1时
//补码：11111111111111111111111111111111
//无符号位原码反码补码相同，将其转换为10进制后为4294967295
//所以会无限循环下去
printf("%u\n", i);
}
可以看出char无论是有符号还是无符号都是一个循环。
unsigned char i = 0;
int main()
{
for(i = 0;i<=255;i++)
{
printf("hello world\n");
}
return 0;
}
讲解：
unsigned char i = 0;
int main()
{
//i为无符号，无符号的char始终小于255，所以为无限循环
for(i = 0;i<=255;i++)
{
//当i = 255再加一时会变为0，所以会无限循环下去
printf("hello world\n");
}
return 0;
}
三、浮点型在内存中的存储
在开始讲解之前，我们先来一个“引子”
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;
}
其打印结果为：
第一个和第四个答案可能没有问题，在中间的两个为什么是上述结果呢，接下来会详细讲解
浮点数存储规则
为了理解上述结果，一定要先搞懂浮点数在计算机内部的表示方法
根据国际标准IEEE（电气和电子工程协会） 754规定，任意一个二进制浮点数可以表示成下面的形式：
(-1) ^ S* M * 2 ^ E
(-1) ^ S表示符号位，当S = 0时为正数；当S = 1时为负数。
M表示有效数字，1≤M < 2。
2 ^ E表示指数位
举例：
十进制：5.5
二进制：101.1
而它就可以表示成：(-1)^0 * 1.011 * 2^2
其中 S = 0; M = 1.011; E = 2
不难发现这和十进制的科学计数法相似，其实这就是二进制的科学计数法，那么浮点数在计算机内部具体怎么存储呢？
IEEE 754规定： 对于32位的浮点数（也就是单精度浮点数float，占4个字节，32个比特位），最高的1位是符号位S，接着的8位是指数E，剩下的23位为有效数字M（S，E，M当然都是转成二进制存储到计算机中）
对于64位的浮点数（双精度浮点数double，占8个字节，64个比特位），最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M
IEEE 754对有效数字M和指数E，还有一些特别规定
对于M
前面说过， 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的计算值减去127（或1023），得到真实值，再将有效数字M前加上第一位的1
比如：
0.5的二进制形式为0.1，由于规定正数部分必须为1，则为1.0 * 2 ^ (-1)，其指数E为 - 1 + 127 = 126，表示为01111110，而尾数1.0去掉整数部分为0，补齐0到23位 00000000000000000000000，则其二进制表示形式为 :0 01111110 00000000000000000000000
E全为0时：
这时，浮点数的指数E等于1-127（或者1-1023）即为真实值， 有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。
E全为1时：
这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）；
浮点数的表示规则就讲到这里，接下来我们再回到一开始的题并进行讲解：
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;
}
9的二进制序列：
原码/反码/补码：00000000000000000000000000001001
上述代码将n的地址强制转化为float*类型存入到float*类型的指针pFloat中，此时编译器会将9视为浮点数
存入：
0 00000000 00000000000000000001001
S E M
取出：
S = 0
E = 1 - 127 = -126（因为上面的数E为全0）
M = 0.00000000000000000001001
也就是(-1)^0 * 0.00000000000000000001001 * 2^-126 ------这是一个非常小的数
在第二个printf函数中以%f的形式将浮点数9从*pFloat中取出，因为float只会读取小数点的后6位，所以打印结果为0.000000
接下来*pFloat = 9.0
9.0的二进制序列：
存入：
1001.0 -------> (-1)^0 * 1.001 * 2^3
S = 0
E = 3 + 127 =130
M = 1.001
0 10000010 00100000000000000000000
取出：
将0 10000010 00100000000000000000000视为整数，还原为10进制后：1091567616
993
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
