C语言中的这个小细节你知道吗?
Posted 捕获一只小肚皮
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C语言中的这个小细节你知道吗?相关的知识，希望对你有一定的参考价值。
文章目录
既然题目都说了是小细节,一来就介绍细节多没意思啊,先坑坑大家再详细介绍吧,嘿嘿.直接上7个题吧,看看你能做对几个呢?
计算型细节
①:
#include <stdio.h>
int main()
{
char a = 3;
char b = 127;
char c = a + b;
printf("结果是:%d",c);
return 0;
}
您想想这个题的答案是多少?先不要看后面的答案哦
答案是 -126, 嘿嘿,是不是答错了呢?先不要着急,继续看下面的题
②:
#include <stdio.h>
int main()
{
char a = 0xb6;
short b = 0xb600;
int c = 0xb6000000;
if(a==0xb6)
printf("a");
if(b==0xb600)
printf("b");
if(c==0xb6000000)
printf("c");
return 0;
}
您想想这个题的答案是什么呢? 先不要看后面的答案哦
答案是 c,嘿嘿,是不是又回答错误,先不要着急,再看看后面的题
③:
#include <stdio.h>
int main()
{
char c = 1;
printf("%u\\n", sizeof(c));
printf("%u\\n", sizeof(+c));
printf("%u\\n", sizeof(-c));
return 0;
}
您想想这个题的答案是什么呢? 先不要看后面的答案哦
答案是1 4 4,嘿嘿,是不是又回答错误,先不要着急,再看看后面的题
表达式细节
①:
#include <stdio.h>
int main()
{
int c = 3;
int ret = c + --c;
printf("%d",ret);
return 0;
}
您想想这个题的答案是什么呢? 先不要看后面的答案哦
答案是 5 或者 4,是不确定的,嘿嘿,是不是又回答错误,先不要着急,再看看后
面的题
②:
int main()
{
int i = 10;
i = i-- - --i * ( i = -3 ) * i++ + ++i;
printf("i = %d\\n", i);
return 0;
}
您想想这个题的答案是什么呢? 先不要看后面的答案哦
答案有很多个,在不同的编译器结果不同,也就是说还是不能确定结果,嘿嘿,是不是仍然回答错误了,先不要着急,再看看后面的题
③:
#include <stdio.h>
int fun()
{
static int count = 1;
return ++count;
}
int main()
{
int answer;
answer = fun() - fun() * fun();
printf( "%d\\n", answer);//输出多少？
return 0;
}
您想想这个题的答案是什么呢? 先不要看后面的答案哦
答案是不同编译器不同结果,嘿嘿,是不是又回答错误,先不要着急,再看看后面的题
④:
#include <stdio.h>
int main()
{
int i = 1;
int ret = (++i) + (++i) + (++i);
printf("%d\\n", ret);
printf("%d\\n", i);
return 0;
}
这是最后一个题了,你目前答对了几道了呢??请在评论回答试试.嘿嘿
这个题的答案是不同编译器不同结果
大家回答对了几道题?欢迎评论
1.现在正式讲解上面所有的题设计到的内容--------表达式求值
表达式求值的顺序一部分是由操作符的优先级和结合性决定。
同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。
1.1隐式类型转换 (整型截断与提升)
什么是隐式类型转换,整型提升,整型截断?
C的整型算术运算总是
至少以满足整型类型的精度来进行的。
为了获得这个精度，表达式中若有char和short类型必须在使用之前转换称为整型,这个过程叫做整型提升
.
一个较大数据类型存储在较小数据类型中的过程叫做整型截断,比如整型a = 500,但是a把他的值放到了字符型b中,b不能完全存放a,就会发生整型截断
.
而这个转换行为叫做隐式类型转换
1.1.1 第一题讲解
#include <stdio.h>
int main()
{
char a = 3;
char b = 127;
char c = a + b;
printf("结果是:%d",c);
return 0;
}
我们知道计算机中一切都是操作的补码.所以这里也是一样,(不明白原码补码反码的自己去百度下哦).
其中 正数的 原码 反码 补码 一模一样
… …负数的 补码是反码加一,反码是原码除了符号位所有位都按位取反
a只有1个字节,他的补码是00000011(二进制)
b只有1个字节,他的补码是01111111(二进制)
a加b,进行了算术操作,需要提升到4个字节.而整型提升有两种方式
- 算术提升:在最前面补符号位数字,直到32位
- 逻辑提升:无论什么都只补0,直到32位
大多数计算器都是进行的算术提升,这里便讲解算术提升.
a算术提升后就是00000000000000000000000000000011
b算术提升后就是00000000000000000000000001111111
a+b的结果是------00000000000000000000000010000010
存进c里面,c又只有1个字节,所以发生整型截断,只存取最后8位
10000010
此时c存取的是补码,且c是有符号型,记住了!!,打印显示时候会还原位原码的,该补码对应的数字就是 -126
下面有张字符类型原码补码反码的对应理解图
所以有符号的范围是 [-128,127]
无符号的范围是[0,255]
变成圆圈更好理解,自己按照有无符号对应去找就行.
1.1.2 第二题讲解
#include <stdio.h>
int main()
{
char a = 0xb6;
short b = 0xb600;
int c = 0xb6000000;
if(a==0xb6)
printf("a");
if(b==0xb600)
printf("b");
if(c==0xb6000000)
printf("c");
return 0;
}
0xb6的二进制是 00000000000000000000000010110110
存进去a中,发生截断,得到1011 0110
0xb600的二进制是00000000 00000000 10110110 00000000
存进去b中发生截断,得到10110110 00000000
0xb600000010110110 00000000 00000000 00000000
存进去c中刚刚好.
a此时存的是补码,a又与0xb6比较,参与了运算,所以又整型提升为
11111111 11111111 11111111 10110110,
- 整型提升后的数字与0xb6的二进制不一样,所以不等.
b此时存的是补码,b又与0xb600比较,参与了运算,所以又整型提升为
11111111 11111111 10110110 00000000
- 整型提升后的数字与0xb600的二进制不一样,所以不等
c此时存的是10110110 00000000 00000000 00000000,注意哦~,有人可能会问0xb6000000是正数啊,不!!!!!,字面常量只要不带符号就是默认int类型.所以此时0xb6000000的整数值是超过int的,就会认为它此时的二进制是负数的补码.所以c与0xb6000000是相等的.
1.1.3 第三题讲解
#include <stdio.h>
int main()
{
char c = 1;
printf("%u\\n", sizeof(c));
printf("%u\\n", sizeof(+c));
printf("%u\\n", sizeof(-c));
return 0;
}
sizeof测量的是类型属性的值.
c的类型是char,只有一个字节,所以答案是1
+c,+是单目操作符,与c在一起发生了整型提升,变成了int,所以是4个字节,答案是 4
-c,同样的道理,仍然是4
1.2算术转换
上面我们说到,如果操作数大小 小于int,会发生整型提升,但是如果都是大于等于int大小的类型参与算术运算呢?? 这里就会涉及到
算术转换.
什么是算术转换呢? 比如下面的例子:
#include <stdio.h>
int main()
{
int a = -127;
unsigned int b = 129;
if(a > b)
{
printf("a会大于b");
}
return 0;
}
结果会打印 a会大于b
因为这就是算术转换,即还是需要满足同类型运算,unsigned int 比int 高,所以a的值会默认是 无符号的,a就会比b大.
算术提升方向:
1.3 操作符属性
复杂表达式的求值有三个影响的因素。
- 操作符的优先级
- 操作符的结合性
- 是否控制求值顺序。
1.3.1 什么是优先级?
就是决定先计算什么.比如d = a + b*c. 因为*的优先级高于+,所以,先算b*c,再算+
1.3.2 什么是结合性?
就是同样优先级,就决定从哪个方向计算.比如d = a * b * c ,因为连续的*,优先级已经没有用了,所以此时就是结合性,*的结合性是从左到右.也就是说先计算a*b 然后计算*c.
1.3.3 什么是求值顺序?
就是只计算哪边.c语言的操作符具有求值顺序的只有寥寥几个,比如||, && , !
那求值顺序到底什么意思呢?
比如a等于0,b等于2,c等于3,d = a && b && c,d的值最后是0,但是在运算时候只到a就完结了,因为&&是只要碰到假就是假,后面的真假已经无关,a为0,是假,所以后面不用再管.这就是求值顺序.
下面有两个关于求值顺序的小练习:
#include <stdio.h>
int main()
{
int i = 0,a=0,b=2,c =3,d=4;
i = a++ && ++b && d++;
printf("a = %d\\n b = %d\\n c = %d\\nd = %d\\n", a, b, c, d);
return 0;
}
答案是 1 2 3 4.理由: a是后置++,先使用a=0的值,一开始就遇到假了,后面不再执行.但是a还是增加了的,因为后置加加是 先使用再加加
#include <stdio.h>
int main()
{
int i = 0,a=0,b=2,c =3,d=4;
i = ++a || ++b || d++;
printf("a = %d\\n b = %d\\n c = %d\\nd = %d\\n", a, b, c, d);
return 0;
}
答案:1 2 3 4,前置++,即先加加,a成了1,因为||一遇到真就结束,不再管后面真假.所以只有a变化了.
这里有张操作符属性的表:
其中优先级从上往下逐渐降低
1.3.4 第四题讲解
#include <stdio.h>
int main()
{
int c = 3;
int ret = c + --c;
printf("%d",ret);
return 0;
}
ret = c + --c中有两个操作符号,先看优先级,--的优先级高于+,所以决定了先算–c,但是+号左边的c是什么时候准备的呢? 我们知道,c语言是编译性语言,在代码写好以后是需要先进行编译为机器语言,然后执行的.那么在编译时候,+号左边的值是在--c之前就已经编译好了呢,还是--c之后编译好了呢?这是不确定的.
- 在vs编译器下答案是 4,他是在
--c之后准备好了c - 在gcc编译器下答案是 5,他是在
--c之前准备好了c
所以: 这是问题代码,我们以后不要写这样的垃圾代码.
1.3.5 第五题讲解
int main()
{
int i = 10;
i = i-- - --i * ( i = -3 ) * i++ + ++i;
printf("i = %d\\n", i);
return 0;
}
这个是同样的道理,虽然知道优先级,但是结合性中的操作数什么时候准备不确定,你看看在不同的编译器操作的结果:
同样是个垃圾代码
1.3.6 第六题讲解
#include <stdio.h>
int fun()
{
static int count = 1;
return ++count;
}
int main()
{
int answer;
answer = fun() - fun() * fun();
printf( "%d\\n", answer);//输出多少？
return 0;
}
()函数调用符号优先级最高,但是这里有三个,到底先调用哪个呢??这又不确定了.
- vs编译器是从左往右依次调用的,结果为-10.
- 但是其他编译器呢??大家去试试gcc,codeblocks,Devc++,你一定会发现完全不一样.
1.3.7 第七题讲解
再说这个题之前,博主一定要批判某些高校,为什么呢??学校教大家++符号时候是不是最喜欢用这种类型来考大家?在这明确告诉大家,这完全是在浪费时间!!!因为这种代码根本没有意义!!!.就是垃圾代码
#include <stdio.h>
int main()
{
int i = 1;
int ret = (++i) + (++i) + (++i);
printf("%d\\n", ret);
printf("%d\\n", i);
return 0;
}
首先,()括号的优先级最高,但是有三个,到底先计算哪个?
其次,一个i的变化,会不会影响另外的?这里也不确定.和第四题我们说的那个编译之前c到底什么时候准备一样.不确定.!!!
- vs编译器的值是 12 4
- gcc编译器的值是 10 4
不同的编译器不同的值,结果不一样,这样的代码不配叫代码.!!!
所以,以后看到这种题直接跳过,没有意义.
总结:
- 知道了什么是整型提升与截断
- 知道了什么是算术转换
- 知道了什么操作符的属性,以后不能写出这种类似的垃圾代码.
以上是关于C语言中的这个小细节你知道吗?的主要内容，如果未能解决你的问题，请参考以下文章