C语言初阶深入探索C语言操作符的奥秘（下）！！

Posted 2021-05-18  Do

目录

 

操作符和表达式

表达式求值

隐式类型转换

整型提升的意义

如何进行整体提升

算术转换

操作符的属性

运算符优先级和结合性一览表

一些容易出错的优先级问题

一些问题表达式

1.a*b + c*d + e*f

2.c + --c

3.int ret=(++i)+(++i)+(++i)

4.answer = fun() - fun() * fun()

代码示例

1.求两个数二进制中不同位的个数

2.打印整数二进制的奇数位和偶数位

3.统计二进制中1的个数

总结

---

操作符和表达式

本篇内容接上一篇，主要讲解表达式的求值，以及一些题目的求解。最重要的是博主会讲到一些问题表达式，让大家在以后的代码学习中少走弯路，写出更好的代码。

表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。 同样，有些表达式的操作数在求值的过程中可能需要类型转换。

隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。 为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。

整型提升的意义

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度 一般就是int的字节长度，同时也是CPU的通用寄存器的长度。

因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。

通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转 换为int或unsigned int，然后才能送入CPU去执行运算。

也就是说字符型或者短整型数值参与运算时，要转换为整型才能参与运算。

代码举例：

char a,b,c;
...
a = b + c；

b和c的值为char型，不够int型，所以要提升为普通整型，然后再执行加法运算。 加法运算完成之后，由于结果是int型，但最终要存储到字符型a中，所以结果将被截断，然后再存储于a中

那么b和c是如何整型提升的呢？

如何进行整体提升

整形提升是按照变量的数据类型的符号位来提升的。

负数的整型提升

char c1 = -1;
变量c1的二进制位(补码)中只有8个比特位：
1111111
因为 char为有符号的char
所以整形提升的时候，高位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111

正数的整型提升

char c2 = 1;
变量c2的二进制位(补码)中只有8个比特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为0
提升之后的结果是：
00000000000000000000000000000001
//无符号整形提升，高位补0

整型提升的例子

案例1：

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;
}

实例1中的a,b参与运算要进行整形提升,但是c不需要整形提升 a,b整形提升之后,变成了负数,所以表达式 a==0xb6 , b==0xb600 的结果是假,但是c不发生整形提升,则表达式 c==0xb6000000 的结果是真. 所程序输出的结果是: c

案例2：

int main()
{
 char c = 1;
 printf("%u\\n", sizeof(c));
 printf("%u\\n", sizeof(+c));
 printf("%u\\n", sizeof(!c));
 return 0;
}

 

实例2中的,c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字节. 表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof(c) ,就是1个字节。

案例3：
 

#include<stdio.h>
int main()
{
	char a = 3;
	char b = 127;
	char c = a + b;
	printf("%d\\n", c);

}

这里的a和b是char型，没有达到int型大小。所以需要先整型提升再参与运算。然后截取前8位存储到c中。但是要打印的是整型，所以c也要整型提升。提升后是补码，还要转换成原码打印出来。

算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换

long double

double

float

unsigned long int

long int

unsigned int

int

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。也就是说，精度低的要向精度高的转换。

算术转换适用于int类型及以上，但是隐式类型转换适用于int类型以下。

但是算术转换要合理，要不然会有一些潜在的问题：

float f = 3.14;
int num = f;//隐式转换，会有精度丢失

操作符的属性

复杂表达式的求值有三个影响的因素：

1. 操作符的优先级

2. 操作符的结合性

3. 是否控制求值顺序。

两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。

运算符优先级和结合性一览表

 

上表中可以总结出如下规律：

1. 结合方向只有三个是从右往左，其余都是从左往右。
2. 所有双目运算符中只有赋值运算符的结合方向是从右往左。
3. 另外两个从右往左结合的运算符也很好记，因为它们很特殊：一个是单目运算符，一个是三目运算符。
4. C语言中有且只有一个三目运算符。
5. 逗号运算符的优先级最低，要记住。
6. 此外要记住，对于优先级：算术运算符 > 关系运算符 > 逻辑运算符 > 赋值运算符。逻辑运算符中“逻辑非 !”除外。

一些容易出错的优先级问题

上表中，优先级同为1 的几种运算符如果同时出现，那怎么确定表达式的优先级呢？这是很多初学者迷糊的地方。下表就整理了这些容易出错的情况：

 

一些问题表达式

1.a*b + c*d + e*f

在计算的时候，由于*比+的优先级高，只能保证，*的计算是比+早，但是优先级并不能决定第三个*比第一个+早执行。

所以表达式的计算机顺序就可能是：

1.a*b
2.c*d
3.a*b + c*d
4.e*f
5.a*b + c*d + e*f

或者：

1.a*b
2.c*d
3.e*f
4.a*b + c*d
5.a*b + c*d + e*f

2.c + --c

同上，操作符的优先级只能决定自减--的运算在+的运算的前面，但是我们并没有办法得知，+操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义的。

3.int ret=(++i)+(++i)+(++i)

原代码是这样的：

#include <stdio.h>
int main()
{
 int i = 1;
 int ret = (++i) + (++i) + (++i);
 printf("%d\\n", ret);
 printf("%d\\n", i);
 return 0;
}

这道题出自《c和指针》这本书，作者分别在vs环境下和linux环境下测试，在vs环境下，是先算三个++i,再算两个+号，结果为12和4。

在vs环境下，是从左到右算，结果为10和4。

也就是说：在执行的时候，第三个++是否执行，这个是不确定的，因为依靠操作符的优先级和结合性是无法决定第一个 + 和第三个前置 ++ 的先后顺序。

4.answer = fun() - fun() * fun()

原代码是这样的：

int fun()
{
     static int count = 1;
     return ++count;
}
int main()
{
     int answer;
     answer = fun() - fun() * fun();
     printf( "%d\\n", answer);
     return 0;
}

虽然在大多数的编译器上求得结果都是相同的。

但是上述代码 answer = fun() - fun() * fun(); 中我们只能通过操作符的优先级得知：先算乘法， 再算减法。 函数的调用先后顺序无法通过操作符的优先级确定

总结

我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。

---

代码示例

1.求两个数二进制中不同位的个数

编程实现：两个int（32位）整数m和n的二进制表达中，有多少个位(bit)不同？ 

输入例子:

1999 2299

输出例子:7

请看代码：

#include<stdio.h>
int Get_diff_bit(int m, int n)
{
	int count = 0;
	int temp = m ^ n;			//利用按位异或原理，相同为0，不同为1；所以只需计算异或之后的二进制数中1的个数就行；
	while (temp)
	{
		temp = temp & (temp - 1);		//每次按位与之后都能消除一个1
		count++;	//按位与几次加几次	
	}
	return count;
}
int main()
{
	int m = 0;
	int n = 0;
	printf("请输入两个数m和n:");
	scanf_s("%d%d", &m, &n);
	int count = Get_diff_bit(m, n);
	printf("count=%d", count);

	return 0;
}

2.打印整数二进制的奇数位和偶数位

获取一个整数二进制序列中所有的偶数位和奇数位，分别打印出二进制序列

请看代码：

#include<stdio.h>
void Print(int m)
{
	int i = 0;
	printf("奇数位：");		//第一位，第三位。。。
	for (i = 30; i >=0; i -= 2)		//比如10为00000000000000000000000000001010，i>=0意思是打印第一个奇数位不用向右移


	{
		printf("%d", ((m >> i) & 1));//二进制各位上的数与1按位与，结果为0则说明m的第i位上有0，结果为1则第i位上有1.
	}
	printf("\\n");
	printf("偶数位：");
	for (i = 31; i >=1; i -= 2)		//比如10为00000000000000000000000000001010，i>=0意思是打印第一个偶数位要向右移一位-


	{
		printf("%d", ((m >> i) & 1));
	}
	printf("\\n");
}
int main()
{
	int m = 0;
	printf("输入一个数m：");
	scanf_s("%d", &m);
	Print(m);




	return 0;


}

3.统计二进制中1的个数

写一个函数返回参数二进制中 1 的个数。

比如： 15    0000 1111 有   4 个 1

请看代码：

#include<stdio.h>
//int Count_bit_one(unsigned int n)		//第一种方法(模2除2的方法）
//{
//	int count = 0;
//	while (n)
//	{
//		if (n % 2 == 1)		//比如13，二进制为1101；13%2=1；13/2=6,6%2=0,6/2=3,3%2=1,3/2=1,1%2=1
//
//		{
//			count++;	//利用count++的次数计算1出现的个数
//		}
//		n = n / 2;		//去掉计算过的1，重新赋值n;
//	}
//	return count;
//}
//int Count_bit_one(int n)		//第二种方法，n向右位移，之后按位与1得到结果为1就++；
//{
//	int i = 0;
//	int count = 0;
//	for (i = 0; i < 32; i++)
//	{
//		if (((n >> i) & 1) == 1)//与1按位与，有0则0，如果低位是1，那么这个数就有一个1
//		{
//			count++;
//		}
//	}
//	return count;
//}
int Count_bit_one(int n)		//第三种算法，利用n与n-1按位与的次数来计算count的次数；

{
	int count = 0;
	while (n)
	{
		n=n&( n - 1);//满2进1，n-1之后，n和n-1其中一个低位为0，一个低位为1.按位与1次就能消除一个1
		count++;
	}
	return count;
}
int main()
{
	int n = 0;
	printf("请输入一个数n：");
	scanf_s("%d",&n);
	int count=Count_bit_one(n);
	printf("%d", count);

	return 0;

}

---

总结

关于c语言操作符的内容就完结啦。在c语言中有各种表达式，这需要我们对操作符的运算法则，优先级以及结合性有深刻的理解，而且这样也可以避免有问题的表达式。通过本章的学习希望大家有所收获，如果有不对的地方，还请大家指出。谢谢大家的阅读，拜托给个一键三连吧！！