- 各种操作符的介绍。
- 表达式求值
**1.**操作符分类：
算术操作符
移位操作符
位操作符
赋值操作符
单目操作符
关系操作符
逻辑操作符
条件操作符
逗号表达式
下标引用、函数调用和结构成员
2. 算术操作符
- 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
- 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
- % 操作符的两个操作数必须为整数。返回的是整除之后的余数。
3. 移位操作符
3.1 左移操作符
移位规则：
左边抛弃、右边补 0
-
- * / %
<< 左移操作符
>> 右移操作符
注：移位操作符的操作数只能是整数。
比特就业课-专注IT大学生就业的精品课程
比特主页：https://m.cctalk.com/inst/s9yewhfr
比特就业课 3.2 右移操作符
移位规则：
首先右移运算分两种：
- * / %
- 逻辑移位
左边用 0 填充，右边丢弃 - 算术移位
左边用原该值的符号位填充，右边丢弃
警告 ⚠ ：
对于移位运算符，不要移动负数位，这个是标准未定义的。
例如：
比特就业课-专注IT大学生就业的精品课程
比特主页：https://m.cctalk.com/inst/s9yewhfr
比特就业课 4. 位操作符
位操作符有：
练习一下：
一道变态的面试题：
不能创建临时变量（第三个变量），实现两个数的交换。
练习：
编写代码实现：求一个整数存储在内存中的二进制中 1 的个数。
int num = 10 ;
num >>- 1 ; //error
& // 按位与
| // 按位或
^ // 按位异或
注：他们的操作数必须是整数。
#include <stdio.h>
int main ()
{
int num1 = 1 ;
int num2 = 2 ;
num1 & num2 ;
num1 | num2 ;
num1 ^ num2 ;
return 0 ;
}
#include <stdio.h>
int main ()
{
int a = 10 ;
int b = 20 ;
a = a^b ;
b = a^b ;
a = a^b ;
printf ( "a = %d b = %d\n" , a , b );
return 0 ;
}
参考代码：
// 方法 1
#include <stdio.h>
int main ()
{
int num = 10 ;
比特就业课-专注IT大学生就业的精品课程
比特主页：https://m.cctalk.com/inst/s9yewhfr
比特就业课 5. 赋值操作符
赋值操作符是一个很棒的操作符，他可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋
值。
int count = 0 ; // 计数
while ( num )
{
if ( num % 2 == 1 )
count ++ ;
num = num / 2 ;
}
printf ( " 二进制中 1 的个数 = %d\n" , count );
return 0 ;
}
// 思考这样的实现方式有没有问题？
// 方法 2 ：
#include <stdio.h>
int main ()
{
int num = - 1 ;
int i = 0 ;
int count = 0 ; // 计数
for ( i = 0 ; i < 32 ; i ++ )
{
if ( num & ( 1 << i ) )
count ++ ;
}
printf ( " 二进制中 1 的个数 = %d\n" , count );
return 0 ;
}
// 思考还能不能更加优化，这里必须循环 32 次的。
// 方法 3 ：
#include <stdio.h>
int main ()
{
int num = - 1 ;
int i = 0 ;
int count = 0 ; // 计数
while ( num )
{
count ++ ;
num = num & ( num - 1 );
}
printf ( " 二进制中 1 的个数 = %d\n" , count );
return 0 ;
}
// 这种方式是不是很好？达到了优化的效果，但是难以想到。
int weight = 120 ; // 体重
weight = 89 ; // 不满意就赋值
double salary = 10000.0 ;
salary = 20000.0 ; // 使用赋值操作符赋值。
比特就业课-专注IT大学生就业的精品课程
比特主页：https://m.cctalk.com/inst/s9yewhfr
比特就业课 复合赋值符
+=
-=
*=
/=
%=
>>=
<<=
&=
|=
^=
这些运算符都可以写成复合的效果。
比如：
6. 单目操作符
6.1 单目操作符介绍
赋值操作符可以连续使用，比如：
int a = 10 ;
int x = 0 ;
int y = 20 ;
a = x = y + 1 ; // 连续赋值
这样的代码感觉怎么样？
那同样的语义，你看看：
x = y + 1 ;
a = x ;
这样的写法是不是更加清晰爽朗而且易于调试。
int x = 10 ;
x = x + 10 ;
x += 10 ; // 复合赋值
// 其他运算符一样的道理。这样写更加简洁。
! 逻辑反操作
- 负值
- 正值
& 取地址
sizeof 操作数的类型长度（以字节为单位）
~ 对一个数的二进制按位取反
-- 前置、后置 --
++ 前置、后置 ++
* 间接访问操作符 ( 解引用操作符 )
( 类型 ) 强制类型转换
比特就业课-专注IT大学生就业的精品课程
比特主页：https://m.cctalk.com/inst/s9yewhfr
比特就业课 演示代码：
关于 sizeof 其实我们之前已经见过了，可以求变量（类型）所占空间的大小。
6.2 sizeof 和 数组
#include <stdio.h>
int main ()
{
int a = - 10 ;
int * p = NULL ;
printf ( "%d\n" , ! 2 );
printf ( "%d\n" , ! 0 );
a = - a ;
p = & a ;
printf ( "%d\n" , sizeof ( a ));
printf ( "%d\n" , sizeof ( int ));
printf ( "%d\n" , sizeof a ); // 这样写行不行？
printf ( "%d\n" , sizeof int ); // 这样写行不行？
return 0 ;
}
#include <stdio.h>
void test1 ( int arr [])
{
printf ( "%d\n" , sizeof ( arr )); //(2)
}
void test2 ( char ch [])
{
printf ( "%d\n" , sizeof ( ch )); //(4)
}
int main ()
{
int arr [ 10 ] = { 0 };
char ch [ 10 ] = { 0 };
printf ( "%d\n" , sizeof ( arr )); //(1)
printf ( "%d\n" , sizeof ( ch )); //(3)
test1 ( arr );
test2 ( ch );
return 0 ;
}
问：
（ 1 ）、（ 2 ）两个地方分别输出多少？
（ 3 ）、（ 4 ）两个地方分别输出多少？
//++ 和 -- 运算符
// 前置 ++ 和 --
#include <stdio.h>
int main ()
{
int a = 10 ;
int x = ++ a ;
比特就业课-专注IT大学生就业的精品课程
比特主页：https://m.cctalk.com/inst/s9yewhfr
比特就业课 7. 关系操作符
关系操作符
这些关系运算符比较简单，没什么可讲的，但是我们要注意一些运算符使用时候的陷阱。
警告：
在编程的过程中 == 和 = 不小心写错，导致的错误。
8. 逻辑操作符
逻辑操作符有哪些：
区分 逻辑与 和 按位与
区分 逻辑或 和 按位或
逻辑与和或的特点：
// 先对 a 进行自增，然后对使用
a ，也就是表达式的值是 a 自增之后的值。 x 为 11 。
int y = -- a ;
// 先对 a 进行自减，然后对使用 a ，也就是表达式的值是 a 自减之后的值。 y 为 10;
return 0 ;
}
// 后置 ++ 和 --
#include <stdio.h>
int main ()
{
int a = 10 ;
int x = a ++ ;
// 先对 a 先使用，再增加，这样 x 的值是 10 ；之后 a 变成 11 ；
int y = a -- ;
// 先对 a 先使用，再自减，这样 y 的值是 11 ；之后 a 变成 10 ；
return 0 ;
}
>
>=
<
<=
!= 用于测试 " 不相等 "
== 用于测试 " 相等 "
&& 逻辑与
|| 逻辑或
1 & 2 -----> 0
1 && 2 ----> 1
1 | 2 -----> 3
1 || 2 ----> 1
比特就业课-专注IT大学生就业的精品课程
比特主页：https://m.cctalk.com/inst/s9yewhfr
比特就业课 360 笔试题
9. 条件操作符
练习：
10. 逗号表达式
逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
#include <stdio.h>
int main ()
{
int i = 0 , a = 0 , b = 2 , c = 3 , d = 4 ;
i = a ++ && ++ b && d ++ ;
//i = a++||++b||d++;
printf ( "a = %d\n b = %d\n c = %d\nd = %d\n" , a , b , c , d );
return 0 ;
}
// 程序输出的结果是什么？
exp1 ? exp2 : exp3
if ( a > 5 )
b = 3 ;
else
b = - 3 ;
转换成条件表达式，是什么样？
2. 使用条件表达式实现找两个数中较大值。
exp1 , exp2 , exp3 , ...expN
// 代码 1
int a = 1 ;
int b = 2 ;
int c = ( a > b , a = b + 10 , a , b = a + 1 ); // 逗号表达式
c 是多少？
// 代码 2
if ( a = b + 1 , c = a / 2 , d > 0 )
// 代码 3
a = get_val ();
count_val ( a );
while ( a > 0 )
{
比特就业课-专注IT大学生就业的精品课程
比特主页：https://m.cctalk.com/inst/s9yewhfr
比特就业课 11. 下标引用、函数调用和结构成员
-
\] 下标引用操作符
- ( ) 函数调用操作符
接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。 - 访问一个结构的成员
. 结构体 . 成员名
-> 结构体指针 -> 成员名
// 业务处理
a = get_val ();
count_val ( a );
}
如果使用逗号表达式，改写：
while ( a = get_val (), count_val ( a ), a > 0 )
{
// 业务处理
}
int arr [ 10 ]; // 创建数组
arr [ 9 ] = 10 ; // 实用下标引用操作符。
\] 的两个操作数是 arr 和 9 。
#include \
下标引用
rexp[rexp]
lexp L-R
否
.
访问结构成员
lexp.member_name lexp L-R
否
->
访问结构指针成员
rexp->member_name lexp L-R
否
++
后缀自增
lexp ++
rexp L-R
否
后缀自减
lexp --
rexp L-R
否
!
逻辑反
! rexp
rexp R-L
否
~
按位取反
~ rexp
rexp R-L
否
+
单目，表示正值
- rexp
rexp R-L
否
单目，表示负值
- rexp
rexp R-L
否
++
前缀自增
++ lexp
rexp R-L
否
--
前缀自减
-- lexp
rexp R-L
否
*
间接访问
* rexp
lexp R-L
否
&
取地址
& lexp
rexp R-L
否
sizeof
取其长度，以字节
表示
sizeof rexp sizeof( 类
型 )
rexp R-L
否
( 类
型）
类型转换
( 类型 ) rexp
rexp R-L
否
*
乘法
rexp * rexp
rexp L-R
否
/
除法
rexp / rexp
rexp L-R
否
%
整数取余
rexp % rexp
rexp L-R
否
加法
rexp + rexp
rexp L-R
否
减法
rexp - rexp
rexp L-R
否
<<
左移位
rexp << rexp
rexp L-R
否
>>
右移位
rexp >> rexp
rexp L-R
否
>
大于
rexp > rexp
rexp L-R
否
>=
大于等于
rexp >= rexp
rexp L-R
否
<
小于
rexp < rexp
rexp L-R
否
<=
小于等于
rexp <= rexp
rexp L-R
否
比特就业课-专注IT大学生就业的精品课程
比特主页：https://m.cctalk.com/inst/s9yewhfr
比特就业课 操作
符
描述
用法示例
结果类
型
结合
性
是否控制求值
顺序
等于
rexp == rexp
rexp L-R
否
!=
不等于
rexp != rexp
rexp L-R
否
&
位与
rexp & rexp
rexp L-R
否
^
位异或
rexp ^ rexp
rexp L-R
否
|
位或
rexp | rexp
rexp L-R
否
&&
逻辑与
rexp && rexp
rexp L-R
是
||
逻辑或
rexp || rexp
rexp L-R
是
? :
条件操作符
rexp ? rexp : rexp
rexp N/A
是
赋值
lexp = rexp
rexp R-L
否
+=
以 ... 加
lexp += rexp
rexp R-L
否
-=
以 ... 减
lexp -= rexp
rexp R-L
否
*=
以 ... 乘
lexp *= rexp
rexp R-L
否
/=
以 ... 除
lexp /= rexp
rexp R-L
否
%=
以 ... 取模
lexp %= rexp
rexp R-L
否
<<=
以 ... 左移
lexp <<= rexp
rexp R-L
否
>>=
以 ... 右移
lexp >>= rexp
rexp R-L
否
&=
以 ... 与
lexp &= rexp
rexp R-L
否
^=
以 ... 异或
lexp ^= rexp
rexp R-L
否
|=
以 ... 或
lexp |= rexp
rexp R-L
否
， 逗号
rexp ， rexp
rexp L-R
是
一些 问题表达式
注释：代码 1 在计算的时候，由于 * 比 + 的优先级高，只能保证， * 的计算是比 + 早，但是优先级并不
能决定第三个 * 比第一个 + 早执行。
所以表达式的计算机顺序就可能是：
// 表达式的求值部分由操作符的优先级决定。
// 表达式 1
a * b + c * d + e * f
a * b
c * d
a * b + c * d
e * f
a * b + c * d + e * f
比特就业课-专注IT大学生就业的精品课程
比特主页：https://m.cctalk.com/inst/s9yewhfr
比特就业课 值
编译器
---128 Tandy 6000 Xenix 3.2
---95
Think C 5.02(Macintosh)
---86
IBM PowerPC AIX 3.2.5
---85
Sun Sparc cc(K&C 编译器 )
---63
gcc ， HP_UX 9.0 ， Power C 2.0.0
4
Sun Sparc acc(K&C 编译器 )
21
Turbo C/C++ 4.5
22
FreeBSD 2.1 R
30
Dec Alpha OSF1 2.0
36
Dec VAX/VMS
42
Microsoft C 5.1
注释：同上，操作符的优先级只能决定自减 -- 的运算在 + 的运算的前面，但是我们并没有办法得
知， + 操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义
的。
表达式 3 在不同编译器中测试结果：非法表达式程序的结果
或者：
a * b
c * d
e * f
a * b + c * d
a * b + c * d + e * f
// 表达式 2
c + -- c ;
// 代码 3- 非法表达式
int main ()
{
int i = 10 ;
i = i -- - -- i * ( i = - 3 ) * i ++ + ++ i ;
printf ( "i = %d\n" , i );
return 0 ;
}
比特就业课-专注IT大学生就业的精品课程
比特主页：https://m.cctalk.com/inst/s9yewhfr
比特就业课 这个代码有没有实际的问题？
有问题！
虽然在大多数的编译器上求得结果都是相同的。
但是上述代码 answer = fun() - fun() * fun() ; 中我们只能通过操作符的优先级得知：先算乘法，
再算减法。
函数的调用先后顺序无法通过操作符的优先级确定。
Linux 环境的结果：
VS2013 环境的结果：
// 代码 4
int fun ()
{
static int count = 1 ;
return ++ count ;
}
int main ()
{
int answer ;
answer = fun () - fun () * fun ();
printf ( "%d\n" , answer ); // 输出多少？
return 0 ;
}
// 代码 5
#include <stdio.h>
int main ()
{
int i = 1 ;
int ret = ( ++ i ) + ( ++ i ) + ( ++ i );
printf ( "%d\n" , ret );
printf ( "%d\n" , i );
return 0 ;
}
// 尝试在 linux 环境 gcc 编译器， VS2013 环境下都执行，看结果。
比特就业课-专注IT大学生就业的精品课程
比特主页：https://m.cctalk.com/inst/s9yewhfr
比特就业课 看看同样的代码产生了不同的结果，这是为什么？
简单看一下汇编代码 . 就可以分析清楚 .
这段代码中的第一个 + 在执行的时候，第三个 ++ 是否执行，这个是不确定的，因为依靠操作符的优先级
和结合性是无法决定第一个 + 和第
三个前置 ++ 的先后顺序。
总结 ：我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题
的。
本章完
比特就业课-专注IT大学生就业的精品课程
比特主页：https://m.cctalk.com/inst/s9yewhfr
比特就业课 比特就业课-专注IT大学生就业的精品课程
比特主页：https://m.cctalk.com/inst/s9yewhfr
比特就业课