指挥棒：C++ 与运算符

参考

描述

算术运算符

C++ 作为编程语言提供了各种运算符，这其中包含了算术运算符。算术运算符在编程语言中 用于执行各种数学运算操作。在 C++ 中有如下常用的算术运算符：

除法运算

在 C++ 中使用除法运算符进行除法运算时，除法运算符的行为将因操作数（参与运算的数据）的不同而不同，具体如下：

1. 若两个操作数 均为整数，则除法运算的结果将为 整数。
2. 若两个操作数中 存在浮点数，则除法运算的结果将为 浮点数。

举个栗子

#include 
using namespace std;


int main() {
    cout << 5 / 3 << endl;
    cout << 5.0 / 3 << endl;
    cout << 5.0 / 3.0 << endl;
    
    system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

执行结果

1
1.66667
1.66667
请按任意键继续. . .
1
2
3
4

注：

1. 除法操作符作用的两个操作数若为整数时，除法运算的结果将为整数。该 整数并不是由实际计算结果四舍五入后得来的，而是直接去除小数点及小数部分 后所剩余的部分 。

2. 在表达式中，除数不能为零。否则，C++ 将为此抛出异常。

取模运算

取模运算与除法运算的区别在于，除法运算的结果值为 两数相除的结果，而取模运算的结果值为 两数相除所得到的余数。

举个栗子

#include 
using namespace std;


int main() {
    cout << 5 % 3 << endl;
    cout << 0 % 9 << endl;
    cout << 36 % 6 << endl;
    
    system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

执行结果

2
0
0
请按任意键继续. . .
1
2
3
4

注：

1. 取模运算符的操作数不可为浮点数，仅能为整数。否则，C++ 将为此抛出异常。

2. 取模运算符的操作数中若存在负数，则结果值的正负性满足如下规则：
   就 A % B 而言，取模运算的结果值的正负性与操作数 A 相同。

举个栗子

#include 
using namespace std;


int main() {
    cout << -5 % 3 << endl;
    cout << 8 % -20 << endl;
    cout << -3 % -3 << endl;
    cout << -2 % -3 << endl;
    
    system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

执行结果

对于 C++ 来说，-0 与 0 是相同的。故 -3 % -3 的输出结果为 0。

-2
8
0
-2
请按任意键继续. . .
1
2
3
4
5

复合赋值运算符

在 C++ 中，+=、-= 等运算符被称为复合赋值运算符（Compound Assignment Operators）。复合赋值运算符 结合了算术运算符与赋值运算符的功能，可以用来简化对变量值的修改操作。

C++ 所支持的常用复合赋值运算符

举个栗子

#include 
using namespace std;


int main() {
    int a = 97, b = 98, c = 99;
    a += 9;
    b %= 7;
    c /= 33;
    
    cout << "97 + 9 = " << a << endl;
    cout << "98 % 7 = " << b << endl;
    cout << "99 / 33 = " << c << endl;
    
    system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

执行效果

97 + 9 = 106
98 % 7 = 0
99 / 33 = 3
请按任意键继续. . .
1
2
3
4

自增运算符

使用自增运算符可以将类似 a = a + 1 的语句简化为 a++ 或 ++a。其中，a++ 中的 ++ 被称为后置自增运算符；++a 中的 ++ 被称为前置自增运算符。
前置自增与后置自增的区别在于，两者所作用的操作数自增的时机不同。前置自增运算过程中操作数的自增时机 在包含自增语句的表达式执行完毕前完成自增，而后置自增运算过程总操作数的自增时机则 在包含自增语句的表达式执行完毕后完成自增。对此，请参考如下示例：

举个栗子

#include 
using namespace std;


int main() {
    int num = 3;
    // 3 * 6 + 3 * 6 = 36
    cout << 3 * 6 + num++ * 6 << endl;

    num = 3;
    
    // 3 * 6 + 4 * 6 = 42
    cout << 3 * 6 + ++num * 6 << endl;

    system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

执行结果

36
42
请按任意键继续. . .
1
2
3

自减运算符

自减运算符与自增运算符的类似，只是自增运算符最终将实现操作数的 自增，而自减运算符最终将实现操作数的 自减。

比较运算符

比较运算符作用于两个操作数，运算结果为布尔值。C++ 支持如下比较运算符：

举个栗子

#include 
using namespace std;


int main() {
    cout << (3 > 6) << endl;
    cout << (6 >= 6) << endl;
    cout << ('3' == 3) << endl;
    system("pause");
}
1
2
3
4
5
6
7
8
9
10

执行结果

0
1
0
请按任意键继续. . .
1
2
3
4

逻辑运算符

概念

C++ 中的逻辑运算符是用于执行逻辑运算的特殊运算符，逻辑运算符操作 布尔值（true 或 false） 或 布尔表达式（能够产生布尔值的表达式，含有逻辑运算符的表达式也是布尔表达式）以产生布尔结果。逻辑运算符主要用于 控制流程 和 条件测试。

C++ 中存在三种逻辑运算符，具体如下：

举个栗子

由于运算符之间存在 优先级关系，没有考虑到不同运算符之间的优先级可能会导致异常的产生。由于 << 运算符的优先级高于大部分逻辑运算符，故在下述示例中需要 使用括号将逻辑运算表达式括起以提高被包裹表达式的优先级，使得程序能够正常运行。

#include 
using namespace std;


int main() {
    cout << !true << endl;
    cout << (true && false) << endl;
    cout << (true && true) << endl;
    cout << (666 || 0) << endl;
    
    system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

执行结果

0
0
1
1
请按任意键继续. . .
1
2
3
4
5

注：

在 C++ 中，所有的非零值转换为布尔值的结果均为 true；零转换为布尔值的结果为 false 。

短路

逻辑与运算符仅当前一个操作数的转换结果为 true 时，才会计算后一个个操作数。
逻辑或运算符仅当前一个操作数的转换结果为 false 时，才会计算后一个操作数。

逻辑与运算符的第前一个操作数的转换结果为 false 以及逻辑或运算符的前一个操作数为 true 时，都将发生 短路，即后一个操作数不会被计算。

举个栗子

#include 
using namespace std;


int main() {
    int num = 1;
    cout << (true || num++) << endl;
    cout << num << endl;
    cout << (false && num++) << endl;
    cout << num << endl;
    
    system("pause");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

执行结果

在上述代码执行过程中，变量 num 被初始化为 1 后保存的值未曾发生过改变。原因是逻辑运算过程中发生了短路，num++ 均未被执行。

1
1
0
1
请按任意键继续. . .
1
2
3
4
5

为什么需要短路机制？

短路机制 有助于提高程序的效率，在某些情况下可以防止出现不必要的计算，尤其是当条件表达式包含了复杂的计算或者函数调用时。但要注意，短路机制可能导致部分表达式 永远不被执行，这 可能会脱离程序的设计初衷。因此，在设计逻辑运算的过程中，需要 仔细考虑条件表达式的逻辑和代码执行的顺序，以确保程序按照开发者的意愿运行。