目录
本章重点
1. 数据类型详细介绍
2. 整形在内存中的存储:原码、反码、补码
3. 大小端字节序介绍及判断
4. 浮点型在内存中的存储解析
前面我们已经学习了基本的内置类型:
以及他们所占存储空间的大小。
1. 数据类型介绍
前面我们已经学习了基本的内置类型:
char //字符数据类型
short //短整型
int //整形
long //长整型
long long //更长的整形
float //单精度浮点数
double //双精度浮点数
类型的意义:
1. 使用这个类型开辟内存空间的大小(大小决定了使用范围)。
2. 如何看待内存空间的视角。
1.1 类型的基本归类:
整形家族:
为什么 char 算整型:
因为字符类型底层存储的是 ASCII 码值,而ASCII码值也是整数,
所以在归类的时候会把 char 类型归结到整型家族里去。( ASCII码: 美国信息交换标准代码 )
浮点数家族:
构造类型:(自定义类型)
注意事项:如下面数组都是整型数组,但是它们的类型完全不一样
int arr1[10]; // 类型为:int[10]
int arr2[5]; // 类型为:int[5]
指针类型
空类型:
void 表示空类型(无类型)
通常应用于函数的返回类型、函数的参数、指针类型。
2.整形在内存中的存储
看看内存:
2.1原码、反码、补码
数据在内存中以2进制的形式存储:
① 对于整数来说,内存中存储的二进制有3种表示形式:原码、反码、补码。
② 正整数:原码、反码、补码相同。
③ 负整数:原码、反码、补码不同,要进行计算。
负整数原码:按照数据的数值直接写出的二进制序列就是原码
符号位:最高位1表示负数,最高位0表示正数
负整数反码:原码的符号位不变,其他位按位取反,即为反码
负整数补码:反码 +1,得到的就是补码
2.1.1 内存中为何存放补码
虽然整数的二进制表示形式有三种,但是内存中存储的是补码
为什么在内存中存的是补码呢:
在计算机系统中,整数数值一律用补码来表示和存储。原因在于,使用补码,
可以将符号位和数字域统一处理;同时,加法和减法也可以统一处理( CPU只有加法器 )。
此外,补码与补码相互转换,其运算过程是相同的,不需要额外的硬件电路
2.2大小端介绍
再仔细观察下刚才内存中的存储,这次再添加一个 b = 10:
可以看到对于 a 和 b 分别存储的是补码,
但是发现顺序好像是倒过来的,为什么会这样呢?
大端小端存储问题,当一个数据的大小存储到内存空间大于1个字节时,
会存在一个存储顺序的问题,这个存储顺序的问题就有两种,一个为大端,一个为小端。
2.2.1大端模式
作用:把数据的低位保存在内存的高地址处,高位字节序的内容存放在低地址中(正着存)
总结:大端模式,低位放在高地址,高位放在低地址
2..2.2小端模式
作用:把数据的低位保存在内存的低地址处,高位字节序的内容存放在高地址中(倒着存)
总结:小端模式,低位放在低地址,高位放在高地址
2.2.3产生的原因
为什么会有大小端模式之分呢?这是因为在 计算机系统中,是以字节为单位的,
每个地址单元都对应着一 个字节,一个字节为8bit。但是在C语言中除了8bit的char之外,
还有16bit的short型,32bit的long型(要看具体的编译器),另外,对于位数大于8位的处理器,例如16位或者32位的处理器,由于寄存器宽度大于一个字节,
那么 必然存在着一个如何将多个字节安排的问题。正是因为 不同的安排顺序导致了 大端存储模式和 小端存储模式的存在。
例如一个 16bit 的 short 型 x ,在内存中的地址为 0x0010 , x 的值为 0x1122 ,
那么 0x11 为高字节, 0x22 为低字节。对于大端模式,就将 0x11 放在低地址中
即 0x0010 中, 0x22 放在高地址中,即 0x0011 中。小 端模式,刚好相反。
我们常用的 X86 结构是小端模式,而 KEIL C51 则为大端模式。很多的ARM,DSP都为小 端模式。
有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。
2.2.4代码判断大小端
百度_系统工程师笔试题:请简述大端字节序和小端字节序的概念,设计一个小程序来判断当前机器的字节序。
直接放代码:
#include<stdio.h>
int check_sys()
{
int i = 1;
char* p = (char*)&i; // 取第一个字节
return *p; // 返回1表示小端(01 00 00 00),返回0表示大端(00 00 00 01)
}
int main()
{
if (check_sys)
{
printf("小端\n");
}
else
{
printf("大端\n");
}
return 0;
}
2.3有符号数和无符号数
无符号数(unsigned),有符号数(signed)
2.3.1两种char的范围
有符号 char 的范围是: -128 ~ 127
无符号 char 的范围是: 0 ~ 255
signed char 解析:
2.3.2下面七个练习程序各输出什么?
(在下面的注释写解析了)
练习一
#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;
}
// a = -1, b = -1, c = 255
//解析:
//存的都是11111111 以%d打印要整形提升
//a和b都提升为11111111111111111111111111111111 为-1
//c不认为第一位的1是符号位所以整形提升为00000000000000000000000011111111 为255
练习二
#include <stdio.h>
int main()
{
char a = -128;
printf("%u\n",a);
return 0;
}
//解析:
//-128原码为10000000000000000000000010000000
// 反码为01111111111111111111111101111111
// 补码为01111111111111111111111110000000
//计算机存的char a为后8位 10000000
//整形提升按照原来的符号来提升(高位补符号位),提升为11111111111111111111111110000000
//大部分编译器认为char 是有符号的char(标准没规定)
//但标准规定了int short都是有符号的
//
//%u无符号(原反补相同)打印为11111111111111111111111110000000为4294967168
练习三
#include <stdio.h>
int main()
{
char a = 128;
printf("%u\n",a);
return 0;
}
//解析:
//128本来为00000000000000000000000010000000
//计算机存的char a取后8位 为10000000
//整形提升为11111111111111111111111110000000
//%u无符号(原反补相同)打印为11111111111111111111111110000000为4294967168
练习四
#include<stdio.h>
int main()
{
int i = -20;
unsigned int j = 10;
printf("%d\n", i + j);
return 0;
}
//解析:
//-20原码为 10000000000000000000000000010100
// 反码为 11111111111111111111111111101011
// 补码为 11111111111111111111111111101100
//当成无符号为 11111111111111111111111111101100 +
//10为 00000000000000000000000000001010 =
// 11111111111111111111111111110110
//以%d有符号打印为(转化为原码)(符号位不变,其它按位取反后+1)
// 10000000000000000000000000001010 为-10
//当代大学生:(-20)+10怎么能是-10呢 算麻了
练习五
#include<stdio.h>
int main()
{
unsigned int i;
for (i = 9; i >= 0; i--)
{
printf("%u\n", i);
}
return 0;
}
//解析:
//unsigned int>=0,所以i >= 0恒成立,死循环
//9
//8
//7
//6
//5
//4
//3
//2
//1
//0
//4294967295
//4294967294
//4294967293...........
练习六
#include<stdio.h>
int main()
{
char a[1000];
int i;
for (i = 0; i < 1000; i++)
{
a[i] = -1 - i;
}
printf("%d", strlen(a));
return 0;
}
//解析:
//127 01111111
//-128 10000000
//a的变化为:-1 -2 -3 ...-127 -128 127 126 .....1 0 -1 -2........
//strlen:找到\0 既0,0前面有128+127个数字 所以是255
练习七
#include <stdio.h>
unsigned char i = 0;
int main()
{
for (i = 0;i <= 255;i++)
{
printf("hello world\n");
}
return 0;
}
//解析:
//unsigned char最大是11111111 255 (范围是[0,255])
//死循环
3.浮点型在内存中的存储
常见的浮点数:
3.14159
1E10
浮点数家族包括: float、double、long double 类型。
浮点数表示的范围:float.h中定义。
3.1 一个例子
浮点数存储的例子:
#include<stdio.h>
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 浮点数存储规则(IEEE754规定)
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 :10进制
二进制:101.1 → 1.011 * 2^2 → (-1) ^0 * 1.011 * 2^2
s=0 M=1.011 E=2
IEEE 754 规定:
对于32位的浮点数,最高的1位是符号位S,接着8位是指数E,剩下的23位位有效数字M:
对于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位,它的取值范围为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(1/2)的二进制形式为0.1,由于规定正数部分必须为1,即将小数点右移1位, 则为1.0*2^(-1),其阶码为-1+127=126,表示为01111110,而尾数1.0去掉整数部分为0,补齐0到23位 00000000000000000000000,则其二进制表示形式为
0 01111110 00000000000000000000000
② E全为0
这时,浮点数的指数E等于1-127(或者1-1023)即为真实值, 有效数字M不再加上第一位的1,而是还原为 0.xxxxxx的小数。这样做是为了表示±0,以及接近于0的很小的数字。
③ E全为1
这时,如果有效数字M全为0,表示±无穷大(正负取决于符号位s);
3.3解释前面的例子:
下面,让我们回到一开始的问题:为什么 0x00000009 还原成浮点数,就成了 0.000000 ?
首先,将 0x00000009 拆分,得到第一位符号位s=0,后面8位的指数 E=00000000 ,最后23位的有效数字M=000 0000 0000 0000 0000 1001。
9 -> 0000 0000 0000 0000 0000 0000 0000 1001
由于指数E全为0,所以符合上一节的第二种情况。因此,浮点数V就写成:
V=(-1)^0 × 0.00000000000000000001001×2^(-126)
显然,V是一个很小的接近于0的正数,所以用十进制小数表示就是0.000000。
再看例题的第二部分。
请问浮点数9.0,如何用二进制表示?还原成十进制又是多少?
首先,浮点数9.0等于二进制的1001.0,即1.001×2^3。
9.0 -> 1001.0 ->(-1)^01.0012^3 -> s=0, M=1.001,E=3+127=130
那么,第一位的符号位s=0,有效数字M等于001后面再加20个0,凑满23位,指数E等于3+127=130,
即10000010。
所以,写成二进制形式,应该是s+E+M,即
0 10000010 001 0000 0000 0000 0000 0000
这个32位的二进制数,还原成十进制,正是 1091567616 。
4.笔试题
4.1程序的执行结果为( )
#include<stdio.h>
int main()
{
unsigned char a = 200;
unsigned char b = 100;
unsigned char c = 0;
c = a + b;
printf("%d %d", a + b, c);
return 0;
}
A.300 300
B.44 44
C.300 44
D.44 300
解析:
#include<stdio.h>
int main()
{
//二进制可以用计算机转化
unsigned char a = 200;
//200的二进制00000000000000000000000011001000
//存的:11001000
unsigned char b = 100;
//100的二进制00000000000000000000000001100100
//存的:01100100
unsigned char c = 0;
//相加不够int 要整形提升
//00000000000000000000000011001000 +
//00000000000000000000000001100100 =
//00000000000000000000000100101100
c = a + b;
//存到c中c为(后8位)00101100为44
//a+b不存到c中就是00000000000000000000000100101100为300
printf("%d %d", a + b, c); //300 44
return 0;
}
4.2在32位大端模式处理器上变量b等于( )
#include<stdio.h>
int main()
{
unsigned int a = 0x1234;
unsigned char b = *(unsigned char*)&a;
return 0;
}
A.0x00
B.0x12
C.0x34
D.0x1234
解析:
#include<stdio.h>
int main()
{
unsigned int a = 0x1234; //int a是4个字节,存的是0x 00 00 12 34
//假设左边是低地址右边是高地址
//大端里存的就是 00 00 12 34
//小端里存的就是 34 12 00 00
unsigned char b = *(unsigned char*)&a;
//题目说大端,unsigned char*取出的是第一个字节的地址,为00 选A
return 0;
}
4.3在屏幕上打印杨辉三角。
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
……
输入n,表示n行
解析:
由于此题要打印整个杨辉三角的数据而非取出某一项,所以不可避免的一定是要填出每一项,没有偷懒的余地,那就老老实实的根据规律填空即可。按照题设的场景,能发现数字规律为:d[i][j] = d[i - 1][j] + d[i - 1][j - 1]。所以只要按照这个方法填表即可。
法一:
#include<stdio.h>
void yang_hui_triangle(int n)
{
int data[30][30] = { 1 }; //第一行直接填好,播下种子
int i = 0, j = 0;
for (i = 1; i < n; i++) //从第二行开始填
{
data[i][0] = 1; //每行的第一列都没有区别,直接给1,保证不会越界。
for (j = 1; j <= i; j++) //从第二列开始填
{
data[i][j] = data[i - 1][j] + data[i - 1][j - 1]; //递推方程
}
}
for (i = 0; i < n; i++) //填完打印
{
for (j = 0; j <= i; j++)
{
printf("%d ", data[i][j]);
}
printf("\n");
}
}
int main()
{
int n = 0;
scanf("%d", &n);
yang_hui_triangle(n);
return 0;
}
法二:
由于在填第n行的杨辉三角时,只跟第n-1行的杨辉三角产生联系,不会跟之前的有联系,
所以没必要保存每一行的杨辉三角,填一行打一行就行了,这样能让空间复杂度从n^2降低到n。
(空间复杂度是数据结构的内容,现在可以先理解为数组开的空间)
但是在填数据的时候不能对之前的数据覆盖,所以需要从后向前填。
而填杨辉三角顺序对结果是没有影响的,所以可以实现。
#include<stdio.h>
void yang_hui_triangle(int n)
{
int data[30] = { 1 };
int i = 0, j = 0;
printf("1\n"); //第一行就直接打印了
for (i = 1; i < n; i++) //从第二行开始
{
for (j = i; j > 0; j--) //从后向前填,避免上一行的数据在使用前就被覆盖
{
data[j] += data[j - 1]; //公式同上,由于变成了一维,公式也变简单了。
}
for (j = 0; j <= i; j++) //这一行填完就直接打印了。
{
printf("%d ", data[j]);
}
printf("\n");
}
}
int main()
{
int n = 0;
scanf("%d", &n);
yang_hui_triangle(n);
return 0;
}
※这种方法虽然降低了空间复杂度,但只能保存最后一行的数据,
不利于反复查询,两个填法各有各的适用场景。就本题而言,改进后的胜出。
4.4代码题猜凶手
日本某地发生了一件谋杀案,警察通过排查确定杀人凶手必为4个嫌疑犯的一个。
以下为4个嫌疑犯的供词:
A说:不是我。
B说:是C。
C说:是D。
D说:C在胡说
已知3个人说了真话,1个人说的是假话。
现在请根据这些信息,写一个程序来确定到底谁是凶手。
直接在代码注释里写解析:
//分析:
//k表示凶手(killer),0表示假话,1表示真话
//if k==A,a==0,b==0,c==0,d==1;
//if k==B,a==1,b==0,c==0,d==1;
//if k==C,a==1,b==1,c==0,d==1;
//if k==D,a==1,b==0,c==1,d==0;
//所以c是凶手,怎么用代码求出呢?
#include<stdio.h>
int main()
{
char k = 0;
for (k = 'A';k <= 'D';k++)
{
//把四句话用表达式表示出来,真为1,假为0
if ((k != 'A') + (k == 'C') + (k == 'D') + (k != 'D') == 3)
{
printf("%c是凶手\n", k);
}
}
return 0;
}
4.5代码题猜名次
5位运动员参加了10米台跳水比赛,有人让他们预测比赛结果:
A选手说:B第二,我第三;
B选手说:我第二,E第四;
C选手说:我第一,D第二;
D选手说:C最后,我第三;
E选手说:我第四,A第一;
比赛结束后,每位选手都说对了一半,请编程确定比赛的名次。
直接在代码注释里写解析:
//考虑到一共五个人,直接模拟推理有些太难,计算机最擅长的遍历此时就会派上用场,
//将每个人从第1到第5来一遍,则一共会产生5 ^ 5种可能性,这个只需要一个5层循环即可搞定。
//但是这样会导致一些不期望出现的结果出现,因为我并没有查重,所以会出现两个人抢名次的情况,
//也就是两个人或者更多的人名次相同的情况,例如两个第二,三个第三这样的,
//所以即使满足了条件,也要查看一下五个人的名次是否重复,
//这个交给一个函数来执行,只要五个人名次并列,那就返回0,否则返回1即可。
//有了这个思路,就能完成以下代码。
//往后面学习还会有更好的方法
#include <stdio.h>
int checkData(int* p)
{
int tmp[7] = { 0 }; //标记表,实际是哈希表的思路。一开始每个元素都是0。
for (int i = 0; i < 5; i++)
{
if (tmp[p[i]]) //如果这个位置的标记已经是1,则代表重复,直接返回0。
{
return 0;
}
tmp[p[i]] = 1; //如果不是,则给这个位置标记为1。
}
return 1; //全部标记完毕也没有出现重复的情况,代表OK。
}
int main()
{
int p[5] = { 0 }; //0 1 2 3 4分别代表A B C D E
for (p[0] = 1; p[0] <= 5; p[0]++)
{
for (p[1] = 1; p[1] <= 5; p[1]++)
{
for (p[2] = 1; p[2] <= 5; p[2]++)
{
for (p[3] = 1; p[3] <= 5; p[3]++)
{
for (p[4] = 1; p[4] <= 5; p[4]++) //五层循环遍历
{
//这里是五个人的描述,由于比较表达式只有0和1两个结果,
//如果要两个条件有且只有一个为真,
//则可以用比较表达式的值总和为1的方式直接判定。
//别忘了还要判定不能并列。
if (
(p[1] == 2) + (p[0] == 3) == 1 && //B第二,我第三
(p[1] == 2) + (p[4] == 4) == 1 && //我第二,E第四
(p[2] == 1) + (p[3] == 2) == 1 && //我第一,D第二
(p[2] == 5) + (p[3] == 3) == 1 && //C最后,我第三
(p[4] == 4) + (p[0] == 1) == 1 && //我第四,A第一
checkData(p) //不能并列
)
{
for (int i = 0; i < 5; i++)
{
printf("%d ", p[i]);
}
printf("\n");
}
}
}
}
}
}
return 0;
}
本章完(留一张关于智力题的图)
本篇完。