Skip to content

第 2 章:运算符与表达式 ​

本章能学到什么 ​

  • 算术、比较、逻辑三类运算符
  • 整数除法 / 与取余 %,和数学竖式的对应关系
  • 运算符优先级,和数学"先乘除后加减"的对应关系
  • 自增自减 ++、--
  • 类型转换:隐式转换与 static_cast

本章承接第 1 章——格子里已经放好了数据,这一章让数据之间发生运算。本章讲的比较和逻辑运算,是第 4 章"选择结构"判断条件的直接材料。

2.1 从分糖果说起 ​

一盒糖果有 17 颗,要分给 5 个小朋友,每人一样多,剩下的留在盒子里。动手算之前,先看没有运算符的程序会怎样:每人分几颗、剩几颗,都得自己在草稿纸上算好,再把答案写进程序——那程序就只是一个高级计算器外壳,真正的计算还是人在做。

小学数学里的除法竖式早就解决了这个问题:

17÷5=3⋯⋯2

商是 3,余数是 2。C++ 里有两个运算符分别对应这两个结果:/ 求商,% 求余数。程序自己会算,人只要把式子写出来。

竖式里的每个角色,在代码里都有对应:

竖式里的名字17 ÷ 5 里的值代码写法
被除数17candies
除数5kids
商3candies / kids
余数2candies % kids

数学竖式一次算出商和余数两个结果;代码里是两个运算符各算各的。为什么要拆成两个?因为很多时候只要其中一个:分糖果两个都想要,但判断奇偶只要余数(见 2.11 节),算"够不够每人分一颗"只要商。各取所需,就不必为用不上的结果付代价。

还有一个细节:竖式里余数必须比除数小,17÷5 的余数不可能是 6。代码里也一样:17 % 5 的结果只会落在 0 到 4 之间。这个性质后面会反复用到——n % 3 的结果只有 0、1、2 三种,正好给"每三轮换一次动作"当节拍器。

再看一个生活例子:电影 125 分钟,是几小时几分钟?小时数就是 125÷60 的商,分钟数就是余数:

cpp
#include <iostream>

int main() {
    int total = 125;   // 电影总时长(分钟)

    std::cout << total / 60 << " 小时 " << total % 60 << " 分钟" << std::endl;
    return 0;
}

预期输出:

text
2 小时 5 分钟

2.2 算术运算符 ​

运算符含义例子结果
+加3 + 25
-减3 - 21
*乘3 * 26
/除(整数相除只留商)17 / 53
%取余17 % 52

两个容易踩的坑:乘号是 * 不是 ×,数学算式里的 3×2 在代码里写 3 * 2;整数除以整数,结果还是整数,小数部分直接丢掉,17 / 5 得到 3 而不是 3.4。怎么算出 3.4,见 2.6 节的类型转换。

分糖果的完整程序:

cpp
#include <iostream>

int main() {
    int candies = 17;  // 糖果总数
    int kids = 5;      // 小朋友人数

    std::cout << "每人分到 " << candies / kids << " 颗" << std::endl;
    std::cout << "盒子里剩 " << candies % kids << " 颗" << std::endl;
    return 0;
}

预期输出:

text
每人分到 3 颗
盒子里剩 2 颗

2.3 比较运算符 ​

考试是否及格,要看分数和 60 的关系。这类"比一比"的运算结果是第 1 章讲过的 bool:要么 true,要么 false。

运算符含义数学写法例子结果
>大于a>b95 > 60true
<小于a<b95 < 60false
>=大于等于a≥b60 >= 60true
<=小于等于a≤b59 <= 60true
==等于a=b95 == 95true
!=不等于a≠b95 != 92true

最容易写错的是 ==。数学里的等号 = 在 C++ 里拆成了两个符号:= 是赋值(把值放进格子),== 是判断相等(问一句"等不等")。写 if (score = 60) 这种错误到第 4 章会遇到,编译器有时不拦,结果完全不对。

还有一个来自数学习惯的坑。数学里 60≤x≤100 表示"x 在 60 到 100 之间",顺理成章。C++ 里不能照着写 60 <= x <= 100:这句编译能过,但意思全变了——从左往右算,60 <= x 先算出一个 bool(0 或 1),再拿 0 或 1 去比 <= 100,结果永远是 true。正确的写法是拆成两半,用 && 连起来:

cpp
bool inRange = (60 <= x) && (x <= 100);   // x 在 60 到 100 之间

数学的连写是给人看的简写,程序要拆成一步一步。Python 恰好允许这种连写,姊妹册第 2 章有对照(见《Python 从入门到精通》第 2 章)。

2.4 逻辑运算符 ​

报名夏令营要同时满足两个条件:年龄在 10 岁以上,并且已征得家长同意。两个条件合起来才算数,这需要逻辑运算。

运算符含义例子结果
&&并且:两边都真才真true && falsefalse
||或者:有一边真就真true || falsetrue
!取反:真变假!truefalse

用程序判断报名资格:

cpp
#include <iostream>

int main() {
    int age = 11;
    bool parentAgree = true;

    bool canJoin = (age >= 10) && parentAgree;  // 两个条件都满足
    std::cout << "能否报名:" << canJoin << std::endl;
    return 0;
}

预期输出:

text
能否报名:1

bool 输出时 true 显示为 1、false 显示为 0,这一点和第 1 章一致。

再看一个"或者"的例子。科技馆门票规定:12 岁以下或者 65 岁以上免票。写成逻辑表达式:

cpp
bool freeTicket = (age < 12) || (age >= 65);

age 是 10 时左边成立,整个表达式为 true;age 是 70 时右边成立,也是 true;age 是 30 时两边都不成立,结果为 false。真值表(见 2.9 节)里的每一行,都对应一种年龄情况。

逻辑表达式和算术表达式一样,也有值——值是 bool。所以它能赋给变量、能直接输出,到第 4 章还能放进 if 的括号里当判断条件。

2.5 运算符优先级 ​

数学里 3+2×4 先乘后加,结果是 11;程序里 3 + 2 * 4 也是 11,规则完全一样。括号最优先,也和数学一致。

本章出现的运算符,优先级从高到低排列:

优先级运算符说明
高( )括号,最优先
↑++、--、!自增自减、取反
↑*、/、%乘、除、取余
↑+、-加、减
↑>、<、>=、<=、==、!=比较
↑&&逻辑与
↑||逻辑或
低=赋值,最后做

拿不准就加括号。(age >= 10) && parentAgree 里的括号即使不写结果也一样,但写上更清楚,不费任何成本。

优先级相同的运算符,从左往右依次算,和数学里同级运算的规矩一样。10 - 4 - 3 是先算 10 - 4 得 6,再算 6 - 3 得 3;如果误当成"先算后面",就会得到 9。除法和取余也一样:100 / 10 / 2 是 (100 / 10) / 2 得 5,不是 100 / (10 / 2) 得 20。

唯一的例外是赋值:a = b = 0 从右往左执行,先把 0 给 b,再把结果给 a。2.8 节解释了这为什么可行。

2.6 自增自减与类型转换 ​

自增 ++ 与自减 -- ​

游戏里血量加 1、减 1 是最频繁的操作之一。hp = hp + 1 写多了,C++ 给了简写:

cpp
#include <iostream>

int main() {
    int hp = 100;
    hp++;              // 等价于 hp = hp + 1
    std::cout << hp << std::endl;
    hp--;              // 等价于 hp = hp - 1
    std::cout << hp << std::endl;
    return 0;
}

预期输出:

text
101
100

++ 就是第 0 章提到的"C++"这个名字的出处:C 的升级版,C 加一。

++ 写在变量前面和后面有区别:单独一句时没区别;放进表达式里时,a++ 先用旧值再加一,++a 先加一再用新值。初学阶段只用单独一句的写法,等第 5 章循环里再体会差别。Python 里没有这个符号,写法是 hp += 1,姊妹册第 2 章有对照。

类型转换 ​

2.2 节留了个问题:17 / 5 为什么不是 3.4?因为整数除以整数,结果按规定还是整数。想保留小数,至少要有一边是小数类型。

cpp
#include <iostream>

int main() {
    std::cout << 17 / 5 << std::endl;                          // 整数 ÷ 整数
    std::cout << 17.0 / 5 << std::endl;                        // 小数 ÷ 整数
    std::cout << static_cast<double>(17) / 5 << std::endl;     // 显式转换后再除
    return 0;
}

预期输出:

text
3
3.4
3.4

这里发生了两种转换:

转换写法含义
隐式转换17.0 / 55 被自动变成 5.0,不用写任何代码
显式转换static_cast<double>(17)明确告诉编译器:把 17 变成 double

隐式转换的方向是"小的类型向大的类型靠":int 遇到 double,自动升级成 double,信息不丢失。反过来,double 塞进 int 会丢掉小数部分,所以 int x = 3.9; 之后 x 是 3,不是四舍五入的 4。

2.7 【跨语言对照】整数除法与取余 ​

这件事本质上解决什么问题 ​

分糖果这类问题在两种语言里都频繁出现:要商,也要余数。两种语言都提供了一对运算符来解决,写法几乎一样。

各自怎么做 ​

对比项C++Python
求商a / b(整数相除时)a // b
求余a % ba % b
普通除法需要类型配合(见 2.6 节)a / b 永远得小数

两段等价代码:C++ 版就是 2.2 节的分糖果程序,Python 版如下(详见《Python 从入门到精通》第 2 章):

python
candies = 17  # 糖果总数
kids = 5      # 小朋友人数

print("每人分到 " + str(candies // kids) + " 颗")
print("盒子里剩 " + str(candies % kids) + " 颗")

Python 版的预期输出与 C++ 版完全一致:

text
每人分到 3 颗
盒子里剩 2 颗

为什么设计得不一样 ​

差别藏在负数里。-17 / 5 在 C++ 里得 -3,在 Python 里 −17 // 5 得 -4。原因是商有两种取法:C++ 向零取整(砍掉小数部分),Python 向下取整(往数轴左边靠)。正数范围内两种取法结果相同,所以分糖果看不出区别;涉及负数时才分道扬镳。

设计动机不同:C++ 的向零取整直接对应 CPU 指令,一次机器运算就能完成,符合"零开销"的思路;Python 的向下取整保证 a == (a // b) * b + a % b 这条数学关系对负数也成立,表达式更贴近数学直觉。两种取法各有依据,用的时候记住规则即可。

2.8 表达式的值 ​

3 + 2 * 4 这样的式子叫表达式。表达式的特点是:算完之后得到一个值。这个值可以放进变量、送给 cout、或者参与更大的表达式——就像数学里 3+2×4 的值是 11,可以代入任何需要 11 的地方。

C++ 里连赋值本身也是表达式:score = 95 的值就是 95。所以 a = b = 0; 合法——先把 0 赋给 b,这个表达式的值 0 再赋给 a。Python 的做法不同:赋值是"语句",没有值,姊妹册第 2 章有对照说明。

带分号的一整行叫语句,语句是"做一件事"的完整单位。区分很简单:表达式回答问题"算出来是多少",语句发布命令"去做这件事"。

2.9 逻辑运算真值表 ​

&& 和 || 的结果取决于两边的真假,所有组合列出来就是真值表:

aba && ba || b!a
truetruetruetruefalse
truefalsefalsetruefalse
falsetruefalsetruetrue
falsefalsefalsefalsetrue

记忆方式和数学交集并集相通:&& 像交集,两边都成立才算数;|| 像并集,沾一边就算数。真值表不用背。写逻辑表达式时问自己一句:"这件事要几个条件同时成立,还是沾一个就行?"答案自然就对应 && 或 ||。实在拿不准,把四种真假组合各代进去算一遍,和真值表对一下。

2.10 实战:平均分计算器 ​

把本章的东西拼起来,做一个算平均分的小程序。三门课成绩已知,求总分和平均分:

cpp
#include <iostream>

int main() {
    int chinese = 92, math = 98, english = 95;   // 一行声明多个同类型变量

    int total = chinese + math + english;        // 总分:加法表达式
    double average = total / 3.0;                // 3.0 让除法保留小数(见 2.6 节)

    std::cout << "总分:" << total << std::endl;
    std::cout << "平均分:" << average << std::endl;
    std::cout << "数学比语文高:" << (math > chinese) << std::endl;  // 比较表达式的值
    return 0;
}

预期输出:

text
总分:285
平均分:95
数学比语文高:1

三个知识点各就各位:算术表达式算出总分,类型转换保住平均分的小数,比较表达式输出 1(true)。如果把 3.0 改成 3,平均分仍是 95——因为 285 恰好被 3 整除,看不出区别;把英语改成 96,再分别用 3 和 3.0 各跑一次,差别就现身了。动手实验 1 会请你做这件事。

2.11 取余的妙用:判断奇偶 ​

偶数是能被 2 整除的数——用竖式的语言说,n÷2 的余数是 0。翻译成代码就是 n % 2 == 0。

cpp
#include <iostream>

int main() {
    int n = 17;

    std::cout << (n % 2 == 0) << std::endl;  // 余数为 0 才是偶数
    std::cout << (n % 2 == 1) << std::endl;  // 余数为 1 就是奇数
    return 0;
}

预期输出:

text
0
1

输出 0(false)和 1(true),表示 17 不是偶数、是奇数。判断奇偶是取余最常见的用途;到第 5 章学循环时,"每隔三次做一次"这类节奏控制也靠取余。

2.12 交换两个变量的值 ​

桌上有两杯水,A 杯是可乐,B 杯是橙汁,要把内容换过来。直接倒会混在一起,必须借一个空杯子:A 倒进空杯,B 倒进 A,空杯倒进 B。交换变量一模一样:

cpp
#include <iostream>

int main() {
    int a = 10, b = 20;
    int temp;        // 借来的空杯子

    temp = a;        // 第一步:a 的值存进 temp
    a = b;           // 第二步:b 的值盖掉 a
    b = temp;        // 第三步:temp 里的旧 a 放进 b

    std::cout << "a = " << a << ",b = " << b << std::endl;
    return 0;
}

预期输出:

text
a = 20,b = 10

如果省略 temp,直接写 a = b; b = a;,第一步就把 a 原来的 10 覆盖了,第二步放进去的还是 20——两个变量都成了 20。格子一次只装一个值,这是 1.5 节"x = x + 1"那套动作逻辑的延续。Python 里交换只要一行 a, b = b, a,姊妹册第 1 章介绍过这个便利写法。

动手实验 ​

实验 1:换一组数字分糖果。 把程序改成 23 颗糖分给 4 个小朋友。先用心算预测商和余数,再运行验证。

💡 查看答案
cpp
#include <iostream>

int main() {
    int candies = 23;
    int kids = 4;

    std::cout << "每人分到 " << candies / kids << " 颗" << std::endl;
    std::cout << "盒子里剩 " << candies % kids << " 颗" << std::endl;
    return 0;
}

预期输出:

text
每人分到 5 颗
盒子里剩 3 颗

竖式验证:23÷4=5⋯⋯3。

实验 2:先预测优先级。 不运行,先写出 2 + 3 * 4 % 5 的结果,再写程序验证。

💡 查看答案

* 和 % 同级,从左往右算:先 3 * 4 = 12,再 12 % 5 = 2,最后 2 + 2 = 4。

cpp
#include <iostream>

int main() {
    std::cout << 2 + 3 * 4 % 5 << std::endl;
    return 0;
}

预期输出:

text
4

实验 3:让除法保留小数。 写程序计算 7 除以 2,要求输出 3.5。用 2.6 节的两种办法各写一次。

💡 查看答案
cpp
#include <iostream>

int main() {
    std::cout << 7.0 / 2 << std::endl;                    // 办法一:把一边写成小数
    std::cout << static_cast<double>(7) / 2 << std::endl; // 办法二:显式转换
    return 0;
}

预期输出:

text
3.5
3.5

如果写 7 / 2,只会得到 3。