运算优先级
一句话定义:运算优先级就是"几个运算符撞在一起时,先算谁"的排队规矩。
抓住"括号最大、单目其次、乘除高于加减、赋值最后"这条主线,GESP 的表达式题就不会错。
一、优先级在解决什么问题
一个表达式里同时出现好几个运算符时,计算机不会乱算,它按固定规矩来:
int x = 2 + 3 * 4; // 先算 3 * 4,再算 2 + 12,结果是 14
规矩只有两条:谁优先(优先级)、同级时往哪边算(结合性)。
| 概念 | 回答的问题 | 例子 |
|---|---|---|
| 优先级 | 先算谁 | 2 + 3 * 4 先算 * |
| 结合性 | 同一级,从左还是从右 | 100 - 30 - 20 先算左边 |
| 括号 | 想插队怎么办 | (2 + 3) * 4 |
💡 类比:优先级像食堂排队——括号是会亮工牌的领导,单目运算符是紧跟着领导的人,赋值永远是队尾最后一个打饭的。
二、优先级总表
从高到低,GESP 能遇到的全在这张表里:
| 级别 | 运算符 | 结合性 | 一句话 |
|---|---|---|---|
| 1 | ( ) [ ] 后缀 ++ -- |
左 | 括号永远最先算 |
| 2 | ! ~ + - (类型) ++ -- sizeof |
右 | 单目:只贴着一个数 |
| 3 | * / % |
左 | 乘、除、取余 |
| 4 | + - |
左 | 加、减 |
| 5 | << >> |
左 | 移位 |
| 6 | < <= > >= |
左 | 比大小 |
| 7 | == != |
左 | 判断相等 |
| 8 | & |
左 | 按位与 |
| 9 | ^ |
左 | 按位异或 |
| 10 | 位或(单竖线) | 左 | 按位或 |
| 11 | && |
左 | 逻辑与 |
| 12 | 逻辑或(双竖线) | 左 | 逻辑或 |
| 13 | ? : |
右 | 三目运算 |
| 14 | = += -= *= /= %= |
右 | 赋值 |
| 15 | , |
左 | 逗号 |
第 10、12 行那两个竖线符号,放进表格里会把表格撑坏,这里单独写出来:
int a = 6, b = 3;
cout << (a & b); // 2 按位与
cout << (a ^ b); // 5 按位异或
cout << (a | b); // 7 按位或
cout << (a && b); // 1 逻辑与
cout << (a || b); // 1 逻辑或
看不懂第 8 到第 10 行没关系,那是 GESP 三级以上才会用的位运算;第 11、12 行是二级就考的逻辑运算,先把 1 到 7 背熟。
高 ① 括号 → ② 单目 → ③ 乘除取余 → ④ 加减
⑤ 移位 → ⑥ 比较 → ⑦ 相等 → ⑧ 位与 → ⑨ 异或 → ⑩ 位或
⑪ 逻辑与 → ⑫ 逻辑或 → ⑬ 三目 → ⑭ 赋值 → ⑮ 逗号 低
💡 规律:表越往下,越晚算。所以"赋值"几乎永远是最后一个动作。
2.1 各等级会考到哪几层
| GESP 等级 | 常考范围 | 典型题型 |
|---|---|---|
| 一级 | 1~4 级(括号、乘除、加减) | 给表达式选结果 |
| 二级 | 加 6~7 级、11~12 级 | 判断条件真假 |
| 三级 | 加 5 级、8~10 级 | 位运算求值 |
| 四级以上 | 全表 + 类型转换 | 阅读程序写结果 |
三、四组必须背的相对顺序
3.1 乘除取余,比加减高一级
int a = 2 + 3 * 4; // 14,不是 20
int b = 10 - 6 / 2; // 7,不是 2
int c = 10 % 3 + 1; // 2,先算 10 % 3 = 1
要改顺序只能加括号:
int d = (2 + 3) * 4; // 20
int e = (10 - 6) / 2; // 2
3.2 比较高于相等,相等高于逻辑
这条是二级考试的命门,记住顺序:< <= > >= 高于 == !=,再高于 &&,最后是 ||。
int a = 1, b = 2;
cout << (1 < 2 == 1); // 1(先 1 < 2 得 true,再与 1 比较)
cout << (a == 1 && b > 1); // 1(两边都真)
cout << (0 || 1 && 0); // 0(先 1 && 0 得 0,再 0 || 0)
⚠️
&&比||先算,所以a || b && c等价于a || (b && c),不是(a || b) && c。
3.3 位运算比比较还低
三级以后常见坑:& 的优先级低于 ==,所以下面这行会算歪。
int a = 1, b = 2;
cout << (a & b == 2); // 1:先算 b == 2 得 1,再算 1 & 1 得 1
cout << ((a & b) == 2); // 0:1 & 2 得 0,0 == 2 为假
同一个 a & b,加不加括号结果就反了——这就是位运算不加括号最坑的地方。
💡 你的电脑上开
-Wall编译时,这类地方会跳警告;但 GESP 考试平台只报错、不警告,所以警告救不了你,只能靠加括号。
正确写法永远是给位运算加括号,别赌自己记得住。
3.4 赋值最低,而且从右往左
赋值运算符是右结合,可以连着写:
int a, b, c;
a = b = c = 5; // 等价于 a = (b = (c = 5)),三个都是 5
a += b *= 2; // 先 b *= 2,再把结果加给 a
💡 口诀:比较比逻辑高,位运算比比较低,赋值蹲在最底下。
四、结合性:同一级时往哪边算
4.1 左结合:从左往右
绝大多数运算符是左结合,先算左边那对:
cout << 100 - 30 - 20; // 50,先 100 - 30,再减 20
cout << 12 / 2 / 3; // 2,先 12 / 2,再除以 3
cout << 5 % 3 * 2; // 4,先 5 % 3 得 2,再乘 2
4.2 右结合:从右往左
只有三目运算符和赋值运算符是右结合:
int a = 2;
int x = a > 1 ? 10 : 20; // 10
int y = a > 1 ? 1 : a > 0 ? 2 : 3; // 1,等价于 a > 1 ? 1 : (a > 0 ? 2 : 3)
4.3 同级的加与减、乘与除会混在一起
GESP 很喜欢在"同级"上设套,整数的除法和取余最容易掉坑:
cout << 7 / 2 * 2; // 6,不是 7:先 7 / 2 得 3,再乘 2
cout << 3 * 7 / 2; // 10,不是 9:先乘后除
cout << 3 * (7 / 2); // 9,括号改了顺序
cout << 5 / 2.0; // 2.5:只要有一边是小数,结果就是小数
⚠️ 整数除法会直接扔掉小数部分,
7 / 2是3(不是 3.5)。负数是向零取整,-7 / 2得-3,-7 % 2得-1。
五、GESP 最爱考的六个陷阱
5.1 整数除法:先算谁,结果差一半
算百分比、平均数时,这一步错了整题就错:
int sum = 7, n = 2;
cout << sum / n * 100; // 300(先 7/2 得 3,再乘 100)
cout << sum * 100 / n; // 350(先乘,后除)
cout << 1.0 * sum / n * 100; // 350(先把结果变成小数)
💡 口诀:要做除法先乘后除,或者前面先写
1.0。
5.2 = 和 == 长得很像
int a = 1;
if (a = 0) cout << "真"; // 不输出:赋值结果是 0,条件为假
else cout << "假"; // 走这里,输出"假"(a 也被改成了 0)
if (a == 0) cout << "真"; // 输出"真":这才是判断,不修改 a
5.3 a == b == c 不是"三个都相等"
== 是左结合,先算前两个,结果变成 0 或 1 再去比第三个:
int a = 1, b = 1, c = 1;
cout << (a == b == c); // 1:先 a==b 得 1,1 == 1 成立
int d = 2;
cout << (d == 2 == 1); // 1
cout << (d == 1 == 0); // 1,看着像错的,其实它真成立
5.4 cout 的 << 也参与排队
<< 的优先级比比较运算符高,所以把表达式直接塞进 cout 会算错,甚至编译不过:
cout << 1 + 2; // 3,这个没问题:+ 高于 <<
cout << 2 + 3 > 1; // ❌ 编译错误:(cout << 2 + 3) > 1
cout << (2 + 3 > 1); // 1,加括号就对了
5.5 单目运算符紧紧贴着数字
!、-、++、--、sizeof 都是单目,优先级仅次于括号:
cout << !0 + 1; // 2:先 !0 得 1,再 + 1
int a = 5;
cout << -a * 2; // -10:先取负,再乘
cout << sizeof(int) * 2; // 8:先 sizeof,再乘(int 占 4 字节)
5.6 别把 ++ 和别的运算符混着用
int i = 3;
int x = i++ + ++i; // ❌ 结果不确定,同一变量被改两次,别这么写
写法本身就违规,考试不会让你算它,真遇到这样的选项("结果为 8"之类)直接判错。
六、考场三步法:加括号
不确定优先级时,最稳的办法不是回忆总表,而是把每一步都加括号,一层层拆开。
6.1 拆解示范
原式:2 + 3 * 4 > 10 && 1 || 0
第一步(乘除): 2 + (3 * 4) > 10 && 1 || 0
第二步(加): (2 + 12) > 10 && 1 || 0
第三步(比较): (14 > 10) && 1 || 0
第四步(逻辑): (true && 1) || 0
第五步: true || 0 → true
6.2 三条考场习惯
- 先找括号,有括号先算括号里,一层层往里剥;
- 再找乘除取余,然后加减,一块一块圈出来;
- 最后处理比较、逻辑、赋值,从右往左把赋值补上。
💡 口诀:看不懂就加括号,加完括号答案自己就出来了。
七、自测六题
先自己算,再对答案。
// 第 1 题
cout << 5 / 2 * 2;
// 第 2 题
cout << 2 + 3 % 2 * 4;
// 第 3 题
int x = 2 + 3 > 1;
cout << x;
// 第 4 题
cout << (5 > 3 > 1);
// 第 5 题
int a = 1;
if (a = 0) cout << "真";
else cout << "假";
// 第 6 题
cout << (1 << 2 + 3);
| 题号 | 答案 | 考的是 |
|---|---|---|
| 1 | 4 | 同级左结合,整数除法扔掉小数 |
| 2 | 6 | % 与 * 同级,先算它们 |
| 3 | 1 | 加减高于比较,比较结果变成 0/1 |
| 4 | 0 | > 左结合:先 5>3 得 1,1>1 为假 |
| 5 | 假 | = 是赋值,赋进去的值是 0 |
| 6 | 32 | 加法高于移位:1 << 5 |
总结
💡 全文一句话:优先级管先算谁,结合性管同级往哪边,拿不准就加括号。
- 括号最高,赋值最低,逗号垫底
- 乘除高于加减,比较高于相等,
&&高于|| - 同级左结合,只有三目和赋值从右往左
- 整数除法先乘后除,别让
/抢先 - 考场三步:剥括号 → 圈乘除 → 补赋值
⚠️ 最后一记警钟:
if (a = 0)不报错、a == b == c不报错、5 / 2 * 2更不报错——它们都不会崩,只是悄悄给你一个错答案。GESP 的选择题,就藏在这些"不报错"里。