C++ 运算符：算术、比较、逻辑运算符等

运算符的作用

运算符是对一个或多个值执行某种操作的符号，这些值叫作操作数。你其实已经用过一个了：把值绑定到变量上的 =。C++ 提供了丰富的运算符，用于数学计算、比较、逻辑和位操作，也有几处容易让新手栽跟头的地方。

上一页你看到了 const 如何把一个值固定下来。而运算符是你计算要存储的值的方式，无论这些值是不是常量。下面我们逐一介绍你每天都会用到的几类运算符。

算术运算符

五个算术运算符是 +、-、*、/ 和 %（取模，即除法的余数）：

#include <iostream>
using namespace std;

int main() {
    int a = 17, b = 5;

    cout << "sum:       " << a + b << "\n";
    cout << "difference: " << a - b << "\n";
    cout << "product:    " << a * b << "\n";
    cout << "quotient:   " << a / b << "\n";
    cout << "remainder:  " << a % b << "\n";

    return 0;
}

最大的陷阱就在商里。17 / 5 打印的是 3，而不是 3.4。当两个操作数都是整数时，/ 执行整数除法，丢弃小数部分：它是向零截断，而不是四舍五入。如果你想要真正的小数结果，至少要有一个操作数是浮点数：

#include <iostream>
using namespace std;

int main() {
    int a = 17, b = 5;

    cout << a / b << "\n";          // 3  -> integer division
    cout << 17.0 / 5 << "\n";       // 3.4 -> 17.0 is a double
    cout << (double)a / b << "\n";  // 3.4 -> cast one operand first

    return 0;
}

% 运算符只能用于整数。对 double 使用 % 会导致编译错误，浮点数取余请使用 <cmath> 中的 std::fmod。

赋值与复合赋值运算符

单个 = 表示赋值，而不是比较。C++ 还提供了把运算和赋值合二为一的复合形式，这样就不必重复写变量名：

#include <iostream>
using namespace std;

int main() {
    int score = 10;

    score += 5;   // score = score + 5  -> 15
    score -= 3;   // 12
    score *= 2;   // 24
    score /= 4;   // 6
    score %= 4;   // 2

    cout << score << "\n";   // 2
    return 0;
}

一个经典又让人头疼的错误，是在条件中本想写 == 却写成了 =。if (x = 0) 会把 0 赋值给 x，然后判断结果（为假），而不是进行比较。开启警告后，现代编译器会对此发出警告，所以请保持 -Wall 开启，并认真对待这个警告。

比较运算符

比较运算符提出一个是或否的问题，结果是一个 bool（true 或 false）：

#include <iostream>
using namespace std;

int main() {
    int x = 7, y = 10;

    cout << (x == y) << "\n";  // 0  (false)
    cout << (x != y) << "\n";  // 1  (true)
    cout << (x <  y) << "\n";  // 1
    cout << (x >= 7) << "\n";  // 1

    cout << boolalpha;          // print true/false instead of 1/0
    cout << (x < y) << "\n";    // true
    return 0;
}

默认情况下，cout 把 bool 打印为 1 或 0。向流输出一次 boolalpha，之后这个流就会改用 true/false 这两个单词。

一个隐蔽的陷阱：不要像 1 < x < 10 这样连续比较。它会被解析为 (1 < x) < 10：第一个比较得到一个 bool（0 或 1），再拿它和 10 比较，所以整个表达式几乎总是 true。应该写成 1 < x && x < 10。

逻辑运算符与短路求值

&&（与）、||（或）和 !（非）用于组合布尔表达式。前两个具有短路特性：一旦结果确定，就停止求值。

#include <iostream>
using namespace std;

bool check(const char* label) {
    cout << "checked " << label << "\n";
    return true;
}

int main() {
    // Right side of && is skipped because the left is false:
    if (false && check("A")) {}

    // Right side of || is skipped because the left is true:
    if (true || check("B")) {}

    cout << "done\n";
    return 0;
}

check("A") 和 check("B") 都没有执行，这就是短路求值。它不只是一种优化，更是一种工具。你可以放心地写 if (ptr != nullptr && ptr->ready)，因为只有当 ptr 不为空时才会执行到 ptr->ready，从而避免解引用悬空指针。

自增与自减

++ 加一，-- 减一。它们都有前置和后置两种形式，当你使用表达式的结果时，两者的区别就很重要：

#include <iostream>
using namespace std;

int main() {
    int i = 5;
    cout << ++i << "\n";  // increments to 6, then prints 6 (pre)

    int j = 5;
    cout << j++ << "\n";  // prints 5, THEN increments to 6 (post)
    cout << j   << "\n";  // 6

    return 0;
}

如果你只想要自增这个副作用（比如在 for 循环中），优先使用 ++i。对普通的 int 来说两者没有区别，但对于迭代器这样较重的类型，后置自增必须先复制旧值，这是白白浪费的工作。

还有一个警告：不要在同一个表达式中两次修改同一个变量，比如 i = i++ + 1; 或 arr[i] = i++;。这些更新的顺序是不确定的，结果是未定义行为。每条语句中，每个变量只修改一次。

位运算符与优先级

在底层编程中会用到位运算符：&（按位与）、|（按位或）、^（按位异或）、~（按位取反），以及移位运算符 << 和 >>。

#include <iostream>
using namespace std;

int main() {
    unsigned int flags = 0b0101;   // binary literal: 5

    cout << (flags & 0b0001) << "\n";  // 1  -> bit 0 is set
    cout << (flags | 0b0010) << "\n";  // 7  -> set bit 1
    cout << (flags ^ 0b0101) << "\n";  // 0  -> xor with itself
    cout << (flags << 1)      << "\n"; // 10 -> shift left, doubles it

    return 0;
}

注意：<< 和 >> 同时也是 cout 上的流运算符。在 cout 语句中，通常需要给移位运算加上括号，否则编译器会把它当作流插入。

最后，当你混用多个运算符时，优先级决定了谁先结合。和数学中一样，* 和 / 比 + 和 - 结合得更紧，所以 2 + 3 * 4 等于 14。比较运算符的优先级低于算术运算符，逻辑运算符 &&/|| 更低。拿不准的时候，不要去背完整的优先级表，加上括号就好。(a + b) * c 比指望读者记住规则要清楚得多。

下一步：类型转换

上面你看到 (double)a / b 强制把整数变成了浮点数除法。这就是类型转换（cast）：有意地把一个值从一种类型转换成另一种类型。下一页我们会介绍 C++ 的各种转换工具，从隐式提升到 static_cast，以及每种转换在什么情况下是安全的。