【C++】基础复习 运算符｜算数、关系、逻辑、赋值、位运算符

1 算术运算符

算术运算符用于执行基本的数学运算。

运算符	描述	示例	结果
+	加法	a + b	两数相加
-	减法	a - b	两数相减
*	乘法	a * b	两数相乘
/	除法	a / b	两数相除
%	取模	a % b	取余数
++	自增	++a 或 a++	前置自增或后置自增
--	自减	--a 或 a--	前置自减或后置自减

C++ 中的取余操作符 % 要求操作数必须都是整数类型。

其中对于除法而言,注意一些易错点

在 C++ 中，除法运算符 / 用于将一个数除以另一个数。根据操作数的类型（整数或浮点数），除法运算的结果会有所不同。

1.1 整数除法

整数除法会截断小数部分，仅返回商的整数部分。

示例代码：

#include <iostream>

int main() {
    int a = 7;
    int b = 3;
    int result = a / b; // 整数除法
    std::cout << "7 / 3 = " << result << std::endl; // 输出: 7 / 3 = 2
    return 0;
}

在这个例子中，7 / 3 的结果是 2，因为整数除法会舍弃小数部分。

1.2 浮点数除法

浮点数除法会保留小数部分，返回精确的商。

示例代码：

#include <iostream>

int main() {
    double a = 7.0;
    double b = 3.0;
    double result = a / b; // 浮点数除法
    std::cout << "7.0 / 3.0 = " << result << std::endl; // 输出: 7.0 / 3.0 = 2.33333
    return 0;
}

在这个例子中，7.0 / 3.0 的结果是 2.33333，保留了小数部分。

1.3 混合运算

如果两个操作数一个是整数，一个是浮点数，结果会是浮点数。

示例代码：

#include <iostream>

int main() {
    int a = 7;
    double b = 3.0;
    double result = a / b; // 混合类型除法
    std::cout << "7 / 3.0 = " << result << std::endl; // 输出: 7 / 3.0 = 2.33333
    return 0;
}

注意避免除0

2 关系运算符

关系运算符用于比较两个值，结果是布尔值 true 或 false。

常常用作条件判断

运算符	描述	示例	结果
==	等于	a == b	如果相等，返回 true
!=	不等于	a != b	如果不等，返回 true
>	大于	a > b	如果大于，返回 true
<	小于	a < b	如果小于，返回 true
>=	大于等于	a >= b	如果大于等于，返回 true
<=	小于等于	a <= b	如果小于等于，返回 true

注意多精度浮点型，比较是否相等，应该用一个差值精度去判断

3 逻辑运算符

逻辑运算符用于执行布尔逻辑运算。

常常用作条件判断

运算符	描述	示例	结果
&&	逻辑与	a && b	如果两个操作数都为 true，返回 true
`		`	逻辑或
!	逻辑非	!a	如果操作数为 false，返回 true

4 赋值运算符

赋值运算符用于给变量赋值。

运算符	描述	示例	结果
=	赋值	a = b	将 b 的值赋给 a
+=	加并赋值	a += b	a = a + b
-=	减并赋值	a -= b	a = a - b
*=	乘并赋值	a *= b	a = a * b
/=	除并赋值	a /= b	a = a / b
%=	取模并赋值	a %= b	a = a % b

5 位运算符

位运算符用于对整数类型的二进制位进行操作。

常常进行运算

运算符	描述	示例	结果
&	位与	a & b	对应位都为 1，结果才为 1
`	`	位或	`a
^	位异或	a ^ b	对应位不同，结果为 1
~	位取反	~a	将所有位取反
<<	左移	a << b	将 a 的所有位向左移 b 位
>>	右移	a >> b	将 a 的所有位向右移 b 位

6 条件运算符（三元运算符）

条件运算符用于根据一个布尔表达式的结果返回不同的值。

运算符	描述	示例	结果
?:	条件运算符	condition ? expr1 : expr2	如果 condition 为 true，返回 expr1；否则返回 expr2

示例：

#include <iostream>

int main() {
    int a = 10;
    int b = 20;

    // 算术运算符
    std::cout << "a + b = " << (a + b) << std::endl;
    std::cout << "a - b = " << (a - b) << std::endl;
    std::cout << "a * b = " << (a * b) << std::endl;
    std::cout << "a / b = " << (a / b) << std::endl;
    std::cout << "a % b = " << (a % b) << std::endl;

    // 关系运算符
    std::cout << "a == b: " << (a == b) << std::endl;
    std::cout << "a != b: " << (a != b) << std::endl;
    std::cout << "a > b: " << (a > b) << std::endl;
    std::cout << "a < b: " << (a < b) << std::endl;
    std::cout << "a >= b: " << (a >= b) << std::endl;
    std::cout << "a <= b: " << (a <= b) << std::endl;

    // 逻辑运算符
    std::cout << "(a < b) && (a > 0): " << ((a < b) && (a > 0)) << std::endl;
    std::cout << "(a > b) || (a > 0): " << ((a > b) || (a > 0)) << std::endl;
    std::cout << "!(a == b): " << (!(a == b)) << std::endl;

    // 赋值运算符
    int c = a;
    c += b;
    std::cout << "c += b: " << c << std::endl;
    c -= b;
    std::cout << "c -= b: " << c << std::endl;

    // 位运算符
    int x = 5;  // 0101
    int y = 3;  // 0011
    std::cout << "x & y: " << (x & y) << std::endl;  // 0001
    std::cout << "x | y: " << (x | y) << std::endl;  // 0111
    std::cout << "x ^ y: " << (x ^ y) << std::endl;  // 0110
    std::cout << "~x: " << (~x) << std::endl;        // 1010 (in two's complement)
    std::cout << "x << 1: " << (x << 1) << std::endl; // 1010
    std::cout << "x >> 1: " << (x >> 1) << std::endl; // 0010

    // 条件运算符
    int max = (a > b) ? a : b;
    std::cout << "max: " << max << std::endl;

    return 0;
}

通过理解和掌握这些运算符，可以在 C++ 中高效地进行各种计算和操作，提高编程效率和代码的可读性。

7 其他重点补充

在 C++ 中，浮点数比较是否相等时，应该用一个差值精度去判断，而不是直接使用 == 运算符。这是因为浮点数在计算机中存储时存在精度问题。浮点数的表示在二进制系统中可能无法完全精确地表示某些十进制数，因此直接比较浮点数可能会导致不正确的结果。

原因

1. 浮点数表示的精度问题：
   浮点数在计算机中使用 IEEE 754 标准表示，这种表示法在精度上存在一定的限制。许多十进制数在二进制中无法精确表示，会导致舍入误差。

2. 浮点运算的累积误差：
   在进行多次浮点运算时，舍入误差会累积，导致最终结果与预期值存在微小的差异。

示例

直接比较浮点数：

#include <iostream>

int main() {
    double a = 0.1;
    double b = 0.2;
    double c = a + b;

    if (c == 0.3) {
        std::cout << "c 等于 0.3" << std::endl;
    } else {
        std::cout << "c 不等于 0.3" << std::endl; // 这个分支将会被执行
    }

    return 0;
}

在这个例子中，c 的值实际上是 0.30000000000000004，而不是 0.3，所以直接比较会失败。

使用差值精度判断

为了避免直接比较的误差，应该使用一个小的差值（通常称为 epsilon）来判断两个浮点数是否“足够接近”。

#include <iostream>
#include <cmath>

bool isAlmostEqual(double a, double b, double epsilon) {
    return std::fabs(a - b) < epsilon;
}

int main() {
    double a = 0.1;
    double b = 0.2;
    double c = a + b;
    double epsilon = 1e-9; // 定义一个很小的差值

    if (isAlmostEqual(c, 0.3, epsilon)) {
        std::cout << "c 足够接近 0.3" << std::endl; // 这个分支将会被执行
    } else {
        std::cout << "c 不足够接近 0.3" << std::endl;
    }

    return 0;
}

在这个例子中，isAlmostEqual 函数通过比较 a 和 b 之间的绝对差值是否小于 epsilon 来判断它们是否“足够接近”。这样可以有效避免浮点数比较中的精度问题。