在 Rust 中，操作符（Operators）是用于执行特定运算的符号或关键字。Rust 允许你对自定义的类型进行操作符重载，从而可以定义自己类型的运算规则。下面是一些关于操作符和重载的基本概念。

操作符的基本用法

在 Rust 中，许多基本的算术和逻辑操作符是固定的，例如 +、-、*、/、%、==、!= 等。这些操作符可以用于内建的基本类型，也可以通过 trait 实现来扩展到自定义类型上。
struct Point {
    x: i32,
    y: i32,
}

impl std::ops::Add for Point {
    type Output = Point;

    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

fn main() {
    let point1 = Point { x: 1, y: 2 };
    let point2 = Point { x: 3, y: 4 };

    let sum = point1 + point2;
    println!("Sum: ({}, {})", sum.x, sum.y);
}

在上述例子中，我们实现了 Add trait 来定义 + 操作符的行为，使得我们可以对 Point 类型的对象使用 + 运算。

自定义操作符

Rust 允许创建自定义操作符，不过这种能力受到限制，只能创建一元前缀操作符和二元操作符。自定义操作符的名称由 ASCII 字符组成，可以使用以下字符：

  •  一元前缀操作符：!, -, ~

  •  二元操作符：+, -, *, /, %, &, |, ^, <<, >>


自定义操作符的使用需要通过 trait 实现，以及在使用时引入相应的 trait。
use std::ops::Add;

struct Complex {
    real: f64,
    imag: f64,
}

impl Add for Complex {
    type Output = Complex;

    fn add(self, other: Complex) -> Complex {
        Complex {
            real: self.real + other.real,
            imag: self.imag + other.imag,
        }
    }
}

fn main() {
    let c1 = Complex { real: 1.0, imag: 2.0 };
    let c2 = Complex { real: 3.0, imag: 4.0 };

    let sum = c1 + c2;
    println!("Sum: {} + {}i", sum.real, sum.imag);
}

在上述例子中，我们实现了 Add trait，使得我们可以对 Complex 类型的对象使用 + 运算。

总体来说，Rust 允许你通过 trait 来对操作符进行重载，使得你可以定义自己类型的运算规则，以及在需要时创建自定义操作符。这有助于提高代码的可读性和灵活性。


转载请注明出处：http://www.zyzy.cn/article/detail/6814/Rust