Rust - 运算符

Rust - 运算符

运算符是一个符号，它告诉编译器执行特定的数学、关系或逻辑运算。运算符作用于的值称为操作数（operands）。

例如，在表达式 7 + 5 中，+ 是运算符，7 和 5 是操作数。

Rust 中的主要运算符可以分类为：

• 算术运算符
• 比较运算符
• 逻辑运算符
• 位运算符
• 复合赋值运算符

算术运算符

这些运算符用于执行数学计算。请注意，Rust 是强类型语言，因此在没有显式类型转换的情况下，你不能在操作中混合整数和浮点类型。

fn main() {
    let a = 10;
    let b = 3;

    println!("加法:       {} + {} = {}", a, b, a + b); // 13
    println!("减法:    {} - {} = {}", a, b, a - b); // 7
    println!("乘法: {} * {} = {}", a, b, a * b); // 30
    println!("除法:       {} / {} = {}", a, b, a / b); // 3 (整数除法)
    println!("取模:        {} % {} = {}", a, b, a % b); // 1 (余数)

    // 注意：Rust 不支持自增 (++) 或自减 (--) 运算符。
    // 你必须使用 `a += 1` 或 `a = a + 1` 来代替。
}

比较运算符

比较运算符用于比较两个值并返回布尔结果（true 或 false）。

fn main() {
    let a = 10;
    let b = 20;

    println!("a > b 是 {}", a > b);   // false
    println!("a < b 是 {}", a < b);   // true
    println!("a >= b 是 {}", a >= b); // false
    println!("a <= b 是 {}", a <= b); // true
    println!("a == b 是 {}", a == b); // false
    println!("a != b 是 {}", a != b); // true
}

逻辑运算符

逻辑运算符用于组合多个布尔表达式。它们使用短路求值。

fn main() {
    let is_active = true;
    let has_permission = false;

    // 逻辑与 (&&)：只有当两个操作数都为 true 时才为 true
    println!("活跃 AND 有权限: {}", is_active && has_permission); // false

    // 逻辑或 (||)：只要有一个操作数为 true 就为 true
    println!("活跃 OR 有权限:  {}", is_active || has_permission); // true

    // 逻辑非 (!)：反转布尔值
    println!("不活跃:                {}", !is_active); // false
}

位运算符

位运算符作用于整数操作数的各个位。

fn main() {
    // 使用无符号 8 位整数以清晰演示
    let a: u8 = 0b0101_0101; // 85
    let b: u8 = 0b0011_1100; // 60

    println!("a = {:08b}", a);
    println!("b = {:08b}", b);
    println!("------------------");

    // 位与 (&)
    println!("a & b = {:08b} ({})", a & b, a & b);

    // 位或 (|)
    println!("a | b = {:08b} ({})", a | b, a | b);

    // 位异或 (^)
    println!("a ^ b = {:08b} ({})", a ^ b, a ^ b);

    // 位非 (!)
    println!("!a    = {:08b} ({})", !a, !a);

    // 左移 (<<)
    println!("a << 2 = {:08b} ({})", a << 2, a << 2);

    // 右移 (>>)
    println!("a >> 2 = {:08b} ({})", a >> 2, a >> 2);

    // 注意：Rust 没有单独的零填充右移运算符 (>>>)。
    // 对于无符号整数，`>>` 运算符执行逻辑移位（用 0 填充）
    // 对于有符号整数，则执行算术移位（保留符号位）。
}

复合赋值运算符

这些运算符将算术或位运算与赋值结合起来。

fn main() {
    let mut x = 10;
    println!("初始 x = {}", x);

    x += 5; // 等同于 x = x + 5
    println!("执行 x += 5 后，x = {}", x);

    x -= 3; // 等同于 x = x - 3
    println!("执行 x -= 3 后，x = {}", x);

    x *= 2; // 等同于 x = x * 2
    println!("执行 x *= 2 后，x = {}", x);

    x /= 4; // 等同于 x = x / 4
    println!("执行 x /= 4 后，x = {}", x);

    x %= 3; // 等同于 x = x % 3
    println!("执行 x %= 3 后，x = {}", x);
}

进阶：运算符重载

在 Rust 中，可以通过实现 std::ops 模块中相关的 trait（例如，+ 对应 Add，- 对应 Sub，! 对应 Not）来为自定义类型重载许多运算符。这使得你的自定义类型能够与 Rust 的标准语法无缝集成。