文章目录
数据类型
👀
char 字符数据类型 1个字节
short 短整型 2个字节
int 整形 4个字节
long 长整形 4或8个字节 ，大于等于int
long long 更长整形 8个字节
float 单精度浮点型 4个字节
double 双精度浮点型 8个字节
回顾 了 上面的数据类型
接下来让我们来 了解一下他们的分类
类型的基本归类
😊整形家族
char
unsigned char
signed char
char 虽然是字符数据类型 但字符的本质是ASCII 码值，是整形随意划分到整形家族
思考一下 char 是 signed 有符号的 还是 unsigned 无法号的呢 ， 其实 这个 取决于编译器
short
unsigned short [int]
signed short [int]
int
unsigned int
signed int
long
unsigned long [int]
signed long [int]
long long
unsigned long long[int]
signed long long[int]
😏浮点类型
float
double
🤗构造类型
数组类型
结构体类型 struct
枚举类型 enum
联合类型 union
😁指针类型
eint* pa;
char* pb;
float* pc;
void* pd;
😗空类型
void 表示空类型（无类型）
通常应用于函数的返回类型、函数的参数、指针类类型
第一个 void 表示 函数不会有返回值
第二个 void 表示 函数不需要传任何参数
void test(void)
{
printf("hehe\n");
}
int main()
{
test();
return 0;
}
🐱🐉整形在内存中的存储
计算机中的整数有三种2进制表示方法，即原码、反码和补码。
三种表示方法均有符号位和数值位两部分，符号位都是用0表示“正”，用1表示“负”，而数值位
a = 1;
00000000 00000000 00000000 00000001
a = -1;
10000000 00000000 00000000 00000001
正数的原、反、补码都相同。
负整数的三种表示方法各不相同
原码
直接将数值按照正负数的形式翻译成二进制就可以得到原码。
反码
将原码的符号位不变，其他位依次按位取反就可以得到反码。
补码
反码+1就得到补码。
a = 10;
00000000 00000000 00000000 00001010 --- 10 的原码 反码 补码
正数的 原码 反码 补码 相同
a = -10
10000000 00000000 00000000 00001010 --- -10 的原码
原码 取反（符号位不变其他按位取反） 得 反码
11111111 11111111 11111111 11110101 --- -10 的反码
反码 加一 得 补码
11111111 11111111 11111111 11110110 --- -10 得 补码
😋补码得到 原码的 两种方法
方法 一
-
补码减一
-
反码按位取反等到 原码
a = -10; 11111111 11111111 11111111 11110110 --- -10 得 补码 补码减一 得 反码 11111111 11111111 11111111 11110101 --- -10 的反码 反码符号位不变 其他按位取反 10000000 00000000 00000000 00001010 --- -10 得原码
方法二
1.补码取反
2.然后 加 1 得到 原码
a = -10;
11111111 11111111 11111111 11110110 --- -10 得 补码
补码取反
10000000 00000000 00000000 00001001
加 1
10000000 00000000 00000000 00001010 --- -10 得 原码
🎈整形存储
对于整形来说：数据存放内存中其实存放的是补码。
为什么呢？
在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统
一处理；
同时，加法和减法也可以统一处理（CPU****只有加法器）此外，补码与原码相互转换，其运算过程
是相同的，不需要额外的硬件电路。
这里我们来看
int main()
{
int a = 30;
int b = -10;
return 0;
}
a = 30;
00000000 00000000 00000000 00011110 --- 30 的 补码
我们换成 16进制来看一下 4个 2进制位一个16进制
00 00 00 1e -- 可以看到 30 的 16进制
在来看看 -10 的
11111111 11111111 11111111 11110110 --- -10 得 补码
ff ff ff f6 --- -10 的16进制
接下来我们在编译器中调试打开内存看一下
这里我们发现 a 和 b 的 在 内存中的存储位
a
le 00 00 00
b
f6 ff ff ff
其实这里 与 大小端有关
那什么 是大小端呢
👩大端（存储）模式，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址
中；
👨小端（存储）模式，是指数据的低位保存在内存的低地址中，而数据的高位,，保存在内存的高地
址中。
接下来 我们 写一个 代码 来判断 我们直接的编译器是小端存储还是大端存储
void at()
{
int a = 1;
if (*(char*)&a == 1)
{
printf("小端\n");
}
else
{
printf("大端\n");
}
}
int main()
{
at();
return 0;
}
a = 1
00000000 00000000 00000000 00000001 - 1 的补码
如果 为小端 就为
10000000 00000000 00000000 00000000
大端 为
00000000 00000000 00000000 00000001
我们只需要 通过 将 a 的地址强转为 char* 通过 * 解引用 访问 1 个字节 判断是否为一就能知道
编译器的大小端 了
☺练习
我们学习了知识 当然需要练习了， 接下来趁热打铁，完成下面的练习
😆第一题
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; }
答案 -1 -1 255
解析
char a = -1;
原码
10000000 00000000 00000000 00000001
反码
11111111 11111111 11111111 11111110
补码
11111111 11111111 11111111 11111111
a 为 char 类型 大小为一个字节 要发生截断
11111111
这里 用 %d 打印 又会发生 整形提升 补符号位
11111111 11111111 11111111 11111111 - 补码
最终 原码 为
10000000 00000000 00000000 00000001 所以结果为-1
signed char b=-1; 为 有符号 char
与 char a = -1 同理 所以 答案为 -1;
unsigned char c=-1;
无符号 char
上面我们知道 char 中 存放的 是
11111111
使用%d 打印有符号数 需要 整形提升
unsigned 数不认为 1 为符号为 所以 补 的是 0
unsigned char c = -1
11111111
整形提升后
00000000 00000000 00000000 11111111
🧐第二题
2.
#include <stdio.h>
int main()
{
char a = -128;
printf("%u\n",a);
return 0;
}
答案 4,294,967,168
a = -128;
10000000 00000000 00000000 10000000 --- 原码
11111111 11111111 11111111 01111111 --- 反码
11111111 11111111 11111111 10000000 --- 补码
a 为 char 类型发生截断
1000000 --- a
以 %u 打印 无符号整数
此时 整型提升
11111111 11111111 11111111 10000000
%u 认为内存中存的是无符数 相当于正数 所以原码补码反码相同
所以 这个数就 为 补码 就是
11111111 11111111 11111111 10000000
答案就为4,294,967,168
如果 以%d 呢 就为-128
🤪第三题
接着上面的思考那 打印 128呢
3.
#include <stdio.h>
int main()
{
char a = 128;
printf("%u\n",a);
return 0;
}
答案 4,294,967,168
00000000 00000000 00000000 10000000 --- 128 原码补码反码相同
00000000 00000000 00000000 10000000 --- 128 补码
a 为 char 只能存储 8bit 要发生截断
10000000
%u 打印 发生 整形提升 char 有符号类型提升补符号位
11111111 11111111 11111111 10000000
同理 %u 打印无符号整数
%u 认为内存中存的是无符数 相当于正数 所以原码补码反码相同
所以答案还是 4,294,967,168
%d 打印 就为 -128
有没有思考 一下 为啥 char = 128以 %d 打印 结果为 -128呢
其实 这里 关 char 类型的大小有关
char 1个字节 8个bit 大小 就为 - 2^7 — 2^7-1
-128 — 127
可以看到 char 类型 只能 存放 127 存放不下 为 溢出 就 为 -128 了
😈补充
补充1 char 到底是 signed char 还是 unsigned char c语言标准并没有规定，取决去编译器
int 是 signed int
short 是signed
signed 有符号 的 unsigned 无符号的
第四题
int main()
{
unsigned int i;
for (i = 9; i >= 0; i--) {
printf("%u\n", i);
}
return 0;
}
想一想这里 会打印 出 啥呢
答案 会死循环
为啥呢
其实 道理都差不多
i = 0 时 i-- 此时 i 是不是 会等于 -1
00000000 00000000 00000000 00000000 --- 0 补码
11111111 11111111 11111111 11111111 --- -1 补码
相加
但是 i为 unsigned int 无符号 的i 不认为 1为符号位 所以为一个超级大的数
11111111 11111111 11111111 11111111
当 再次减到 0 时 又会重复上面的操作 所以会死循环
第五题
6.
int main()
{
char a[1000];
int i;
for(i=0; i<1000; i++)
{
a[i] = -1-i;
}
printf("%d",strlen(a));
return 0;
}
想一想 这里 %d 打印 的值是多少
答案 255
char[i] ---> cahr -128 ~ 127
-1 -2 -3 .... -1000
当 -1 到 -128 时 会溢出 此时 在减一
就 为 127 后面继续 i++ 直到0 时
strlen是求字符串的长度 关注的是字符串中'\0'(数字0)
之前出现的多少字符 128 + 127 = 255 所以打印的结果为255
第六题
include <stdio.h>
unsigned char i = 0;
unsigned char 类型的取值范围是0~255
int main()
{
for (i = 0; i <= 255; i++)
{
printf("hello world\n");
}
return 0;
}
答案 会死循环的输出 hello world
因为 unsigend char 的取值范围 为 0 ~ 255
此时 i 能 等于 255 当 i == 255 在加加的时候 就会 从255 溢出到 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;
}
我们 想 这里打印的结果会是
9
9.0
9
9.0
但从编译器来看 会发现 我们只能 对 2 个这是为什么呢
其实这里关 浮点类型在内存中的存储有关，接下来让我们进入到浮点类型的学习
😎浮点数存储规则
num 和 *pFloat 在内存中明明是同一个数，为什么浮点数和整数的解读结果会差别这么大？
要理解这个结果，一定要搞懂浮点数在计算机内部的表示方法。
详细解读：
根据国际标准IEEE（电气和电子工程协会） 754，任意一个二进制浮点数V可以表示成下面的形式：
(-1)^S * M * 2^E
(-1)^S表示符号位，当S=0，V为正数；当S=1，V为负数。
M表示有效数字，大于等于1，小于2。
2^E表示指数位。
这里 我们 来举个例子
(-1)^S * M * 2^E
v = 5.0f 5 的 二进制 101
= 1.01 * 2^2
= (-1)^0 * 1.01 * 2^2;
s = 0 M = 1.01 E = 2;
v = 9.5f; 9 的二级制 1001 0.5 2^-1
9.5的二进制 1001.1
= (-1) *0 * 1.001 * 2^3
s = 0 M = 1.001 E = 3;
我 们知道了 咋算 那接下来 就要存放进内存中了
对于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位，它的取值范围为0255；如果E为11位，它的取值范围为02047。但是，我们
知道，科学计数法中的E是可以出
现负数的，所以IEEE 754规定，存入内存时E的真实值必须再加上一个中间数，对于8位的E，这个中间数
是127；对于11位的E，这个中间
数是1023。比如，2^10的E是10，所以保存成32位浮点数时，必须保存成10+127=137，即
10001001。
总结 ： 上面这么多鸟语 其实就是 存储 浮点类型时 E 要加上一个中间值 如果 32 位下 要加上 127
64 位下 要加上 1023
另外 为了使 浮点类型的 精度提高 会 省去 M 的 小数点前的数 就是 1 那么 在 32 中就会 多一位给M 使用。 取出来时 在将 1 加上就行
这里我们 用 v = 5.5 来举例子 看是 如何存放进 内存中
int main()
{
float f = 5.5f;
5.5 --- 101.1
1.011 * 2^2 因为 f 为 正数 s = 0;
s = 0 M = 1.011 E = 2;
2 + 127 = 129 --- 10000001
0 10000001 01100000000000000000000
这里 E 在32 位编译器下 要加上一个中间值 E + 127
M 去掉 小数点前的 1 就为 011 不够 23位 在 后面补0
换成16 进制
0X 40 b0 00 00
可以看到编译器为 00 00 b0 40 因为 vs 为小端存储
拿出就为 10000001 == 129
(-1) * 0 *1.01100000000000000000000 * 2^(129 - 127) == 5.5
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OXmM8Ls7-1653527178774)(C:\Users\A\AppData\Roaming\Typora\typora-user-images\image-20220525231046331.png)]
当 E 为 全 0 时
这时，浮点数的指数E等于1-127（或者1-1023）即为真实值，
有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于
0的很小的数字
例如
0 00000000 10100000000000000000000
(-1)*0 *1.101*2^(1-127) 会无线接近0 所以 当E 为 全0 时 就当这个数为0
E全为1
这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）；
好了，关于浮点数的表示规则，就说到这里。
0 11111111 10100000000000000000000 ---
(-1) *0 * 1.101*2^(255 - 127) --- 2^128会是一个贼大的数字
这个数字可以 就可以看作一个无穷数字 所以 如果 一个 数 E 为全1 则为 无穷数
了解完 这些 我们就来解释一下上面的那题
int main()
{
int n = 9;
float *pFloat = (float *)&n;
printf("n的值为：%d\n",n);
这里 n = 9 以 %d 打印 就为 9
printf("*pFloat的值为：%f\n",*pFloat);
PFloat 存放的是 n的 地址 而 n 被强转为float 存进了 指针里 然后*pFloat 以%f 打印
他看到内存中9的补码为：
0 00000000 00000000000000000001001 -- 9的 补码
因为 E 为 全 0 所以 打印 的数为 0.000000
*pFloat = 9.0;
printf("num的值为：%d\n",n);
*pFloat 被改为 一个浮点 数 这时 我们来将 9.0 存进去
1001 --> 1.001*2^3
0 10000010 00100000000000000000000
现在 n 存的 补码就为 这个 然后 以%d 打印 就为 一个 蛮大的数
printf("*pFloat的值为：%f\n",*pFloat);
最后以%f 打印就为 9.0
return 0;
}
85
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
