2.4 基本运算符和表达式

在 Rust 中，运算符和表达式是构建程序逻辑的基本单元。表达式是计算并产生一个值的代码片段，而运算符则是对值进行特定操作的符号。Rust 的运算符在大多数情况下与其他 C 语言家族的语言类似，但也包含一些独特的设计，例如不会发生隐式类型转换。

2.4.1 算术运算符

Rust 支持标准的算术运算符，用于对数值类型（如整数和浮点数）进行计算。

运算符名称示例说明
+加法a + b返回两数之和。
-减法a - b返回两数之差。
*乘法a * b返回两数之积。
/除法a / b返回两数之商。整数除法会向零截断。
%取余a % b返回两数相除的余数。

注意：

  • 整数除法会截断小数部分。例如，5 / 2 的结果是 2，而不是 2.5。
  • 尝试除以零会导致程序在运行时发生 panic。
fn main() {
    let sum = 10 + 5;      // 15
    let difference = 10 - 5; // 5
    let product = 10 * 5;   // 50
    let quotient = 10 / 3;  // 3 (整数除法)
    let remainder = 10 % 3; // 1

    println!("Sum: {}", sum);
    println!("Quotient: {}", quotient);
}

2.4.2 比较运算符

比较运算符用于比较两个值，并返回一个布尔值（bool）：true 或 false。

运算符名称示例说明
==等于a == b当 a 和 b 相等时返回 true。
!=不等于a != b当 a 和 b 不相等时返回 true。
>大于a > b当 a 大于 b 时返回 true。
<小于a < b当 a 小于 b 时返回 true。
>=大于或等于a >= b当 a 大于或等于 b 时返回 true。
<=小于或等于a <= b当 a 小于或等于 b 时返回 true。

重要提示： Rust 要求比较运算符两边的操作数类型必须完全相同。例如，你不能直接比较 i32 和 f64 类型的值。

fn main() {
    let x = 10;
    let y = 20;

    let is_equal = x == y;      // false
    let is_not_equal = x != y;  // true
    let is_greater = x > y;     // false
    let is_less_or_equal = x <= y; // true

    println!("Is x equal to y? {}", is_equal);
}

2.4.3 逻辑运算符

逻辑运算符用于组合或反转布尔值。

运算符名称示例说明
&&逻辑与a && b当 a 和 b 都为 true 时返回 true。具有短路特性：如果 a 为 false，则不会计算 b。
``逻辑或
!逻辑非!a对 a 的值取反，将 true 变为 false，反之亦然。
fn main() {
    let a = true;
    let b = false;

    let and_result = a && b;  // false
    let or_result = a || b;   // true
    let not_result = !a;      // false

    println!("AND: {}, OR: {}, NOT: {}", and_result, or_result, not_result);
}

2.4.4 位运算符

位运算符直接在整数的二进制位上操作。

运算符名称示例说明
&按位与a & b对应位都为 1 时结果为 1。
``按位或`a
^按位异或a ^ b对应位不相同时结果为 1。
!按位非!a将每一位取反（0 变 1，1 变 0）。
<<左移a << b将 a 的所有位向左移动 b 位。
>>右移a >> b将 a 的所有位向右移动 b 位。
fn main() {
    let x = 5;  // 二进制: 101
    let y = 3;  // 二进制: 011

    let bitwise_and = x & y;  // 001 -> 1
    let bitwise_or = x | y;   // 111 -> 7
    let bitwise_xor = x ^ y;  // 110 -> 6
    let left_shift = x << 1;  // 1010 -> 10

    println!("Bitwise AND: {}", bitwise_and);
    println!("Bitwise OR: {}", bitwise_or);
    println!("Bitwise XOR: {}", bitwise_xor);
    println!("Left shift: {}", left_shift);
}

2.4.5 赋值运算符与复合赋值运算符

赋值运算符 = 用于将一个值绑定到一个变量。复合赋值运算符将算术或位运算与赋值结合在一起。

运算符示例等价于
=a = b将 b 的值赋给 a。
+=a += ba = a + b
-=a -= ba = a - b
*=a *= ba = a * b
/=a /= ba = a / b
%=a %= ba = a % b
fn main() {
    let mut num = 10;
    num += 5;  // num 现在是 15
    num -= 3;  // num 现在是 12
    println!("Final value: {}", num);
}

2.4.6 类型转换运算符 as

Rust 是一种强类型语言，不会进行隐式类型转换。当你需要将一个数值类型转换为另一种类型时，必须使用 as 关键字进行显式转换。

fn main() {
    let x: i32 = 100;
    let y: f64 = x as f64; // 将 i32 转换为 f64
    let z: u8 = 255;
    let w: i8 = z as i8;   // 注意：如果值超出目标类型范围，可能会发生截断

    println!("x as f64: {}", y);
    println!("z as i8: {}", w); // 输出 -1，因为 255 在 i8 中表示为 -1
}

2.4.7 表达式与语句

理解表达式和语句的区别对于 Rust 编程至关重要。

  • 语句（Statement）：执行一些操作但不返回值的指令。例如，let 变量绑定、函数定义、表达式末尾的分号 ;。
  • 表达式（Expression）：计算并产生一个值的代码片段。例如，5 + 6、函数调用、宏调用、代码块 {...}。

在 Rust 中，几乎一切都是表达式。一个代码块 {...} 的最后一个表达式（不带分号）会成为该代码块的返回值。

fn main() {
    // 这是一个语句，不返回值
    let y = {
        let x = 3;
        x + 1 // 这是一个表达式，其值 4 被赋给 y
    };

    println!("The value of y is: {}", y); // 输出 4

    // 如果加上分号，它就会变成一个语句，返回 ()
    let z = {
        let x = 3;
        x + 1; // 这是一个语句，其值是 ()
    };

    println!("The value of z is: {:?}", z); // 输出 ()
}

总结

本章介绍了 Rust 中常用的运算符和表达式。掌握它们是与 Rust 编译器有效沟通、构建正确且高效程序的基础。请记住，Rust 的类型安全和显式转换原则是其可靠性的重要基石。

Last Updated::