Rust 操作符

Rust 提供了一系列操作符（operators），每种操作符都有特定的功能和应用场景。

1. 算术操作符

这些操作符用于基本的数学运算：

• + : 加法，用于两个数相加。
  • 示例: let sum = 5 + 10;
• - : 减法，用于两个数相减。
  • 示例: let difference = 10 - 5;
• * : 乘法，用于两个数相乘。
  • 示例: let product = 4 * 3;
• / : 除法，用于两个数相除。
  • 示例: let quotient = 10 / 2;
• % : 取余，用于计算两个数的余数。
  • 示例: let remainder = 10 % 3;

2. 比较操作符

这些操作符用于比较两个值，返回一个布尔值：

• == : 相等，用于判断两个值是否相等。
  • 示例: let is_equal = 5 == 5;
• != : 不相等，用于判断两个值是否不相等。
  • 示例: let is_not_equal = 5 != 6;
• > : 大于，用于判断左边的值是否大于右边的值。
  • 示例: let is_greater = 10 > 5;
• < : 小于，用于判断左边的值是否小于右边的值。
  • 示例: let is_less = 5 < 10;
• >= : 大于或等于，用于判断左边的值是否大于或等于右边的值。
  • 示例: let is_greater_or_equal = 10 >= 10;
• <= : 小于或等于，用于判断左边的值是否小于或等于右边的值。
  • 示例: let is_less_or_equal = 5 <= 10;

3. 逻辑操作符

这些操作符用于逻辑运算，通常与布尔值结合使用：

• && : 逻辑与，用于判断两个布尔表达式是否都为 true。
  • 示例: let and_result = true && false;
• || : 逻辑或，用于判断两个布尔表达式是否至少一个为 true。
  • 示例: let or_result = true || false;
• ! : 逻辑非，用于取反一个布尔表达式。
  • 示例: let not_result = !true;

4. 赋值操作符

这些操作符用于将值赋给变量：

• = : 赋值，将右边的值赋给左边的变量。
  • 示例: let x = 5;
• += : 加赋值，将右边的值加到左边的变量上。
  • 示例: let mut x = 5; x += 10;
• -= : 减赋值，将右边的值从左边的变量中减去。
  • 示例: let mut x = 10; x -= 5;
• *= : 乘赋值，将右边的值乘以左边的变量。
  • 示例: let mut x = 2; x *= 3;
• /= : 除赋值，将左边的变量除以右边的值。
  • 示例: let mut x = 10; x /= 2;
• %= : 模赋值，将左边的变量取模右边的值。
  • 示例: let mut x = 10; x %= 3;

5. 位操作符

这些操作符用于对位进行操作，通常用于底层编程或特定算法实现：

• & : 按位与，对两个整数的对应位都为 1 时结果为 1。
  • 示例: let and = 5 & 3; // 结果为 1
• | : 按位或，对两个整数的对应位有一个为 1 时结果为 1。
  • 示例: let or = 5 | 3; // 结果为 7
• ^ : 按位异或，对两个整数的对应位不同则结果为 1。
  • 示例: let xor = 5 ^ 3; // 结果为 6
• ! : 按位非，对整数的每一位取反。
  • 示例: let not = !0b0001_0010; // 结果为 0b1110_1101
• << : 左移，将位向左移动指定的位数（右边补零）。
  • 示例: let left_shift = 1 << 3; // 结果为 8
• >> : 右移，将位向右移动指定的位数（左边补符号位或补零）。
  • 示例: let right_shift = 8 >> 3; // 结果为 1

6. 范围操作符

范围操作符用于生成数值范围：

• .. : 半开区间，从起始值到结束值（不包括结束值）。
  • 示例: for i in 0..5 { println!("{}", i); } // 输出 0 到 4
• ..= : 闭区间，从起始值到结束值（包括结束值）。
  • 示例: for i in 0..=5 { println!("{}", i); } // 输出 0 到 5
• ..（单侧范围）: 生成从起始值到某个值或从某个值到结束值的范围。
  • 示例:
    • let r = 3..; // 从 3 到无穷大
    • let r = ..3; // 从负无穷大到 3

7. 引用与解引用操作符

这些操作符用于处理指针和引用：

• & : 引用操作符，创建一个引用（即指向某个值的指针）。
  • 示例: let x = 5; let y = &x;
• * : 解引用操作符，解引用一个指针或引用，获取其指向的值。
  • 示例: let x = 5; let y = &x; let z = *y;

8. 其他操作符

• . : 成员访问或方法调用。
  • 示例: let len = vec.len();
• .. : 结构体更新语法或元组解构。
  • 示例: let updated = Person { age: 30, ..person };
• [] : 索引操作符，用于访问数组、切片、向量等的元素。
  • 示例: let first = arr[0];
• () : 调用函数或方法，或用于将表达式分组。
  • 示例: let result = add(5, 3);
• ? : 错误传播操作符，用于传播 Result 或 Option 类型的错误。
  • 示例: let value = some_function()?;
• :: : 访问路径操作符
  • 在模块系统中，用于访问模块中的项目（如函数、常量、类型）。
  • 用于调用结构体、枚举的关联函数或静态方法。
  • 从一个模块或包中访问另一个模块或包的项目。
  • 示例:

mod math {
    pub const PI: f64 = 3.14159;
    pub fn add(a: i32, b: i32) -> i32 {
        a + b
    }
}
fn main() {
    let pi = math::PI;
    let sum = math::add(5, 10);
    let origin = Point::origin();
    let color = Color::Red;
}
struct Point {
    x: i32,
    y: i32,
}
impl Point {
    pub fn origin() -> Self {
        Point { x: 0, y: 0 }
    }
}
enum Color {
    Red,
    Green,
    Blue,
}

• as : 转换操作符：用于类型转换，将一个值转换为另一种类型。
  • 示例：

let x = 5;
let y = x as f64; // 将 i32 转换为 f64

• _ : 占位符：
  • 在模式匹配中表示通配符，忽略某个值；或者在类型推断中使用表示不关心的类型。
  • 示例：

let tuple = (1, 2, 3);
let (_, y, _) = tuple;
let v: Vec<_> = (0..10).collect();

• |: 模式匹配中的或操作符：
  • 在模式匹配中表示多种模式的组合，即如果任何一种模式匹配，则匹配成功。
  • 示例：

let x = 1;
match x {
    1 | 2 => println!("One or two"), // 如果 x 是 1 或 2，都会匹配
    _ => println!("Other"),
}

总结

Rust 提供了丰富的操作符，以便开发者在不同的编程场景下使用。每个操作符都有其特定的功能和适用场景，理解它们的用法有助于编写更加高效和清晰的 Rust 代码。

引用

• 运算符与符号