Rust 操作符及示例

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 代码。

引用

• 运算符与符号