运算优先级

一句话定义:运算优先级就是"几个运算符撞在一起时,先算谁"的排队规矩。
抓住"括号最大、单目其次、乘除高于加减、赋值最后"这条主线,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. 先找括号,有括号先算括号里,一层层往里剥;
  2. 再找乘除取余,然后加减,一块一块圈出来;
  3. 最后处理比较、逻辑、赋值,从右往左把赋值补上。

💡 口诀:看不懂就加括号,加完括号答案自己就出来了。


七、自测六题

先自己算,再对答案。

// 第 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 的选择题,就藏在这些"不报错"里。


本站由 奇迹欧埃 使用 Stellar 创建。