运算符与重载

operators-and-overloading.md
commit 6ba952020fbc91bad64be1ea0650bfba52e6aab4

Rust 允许有限形式的运算符重载。特定的运算符可以被重载。要支持一个类型间特定的运算符，你可以实现一个的特定的重载运算符的trait。

例如，+运算符可以通过Add特性重载：

use std::ops::Add;

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

impl 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 p1 = Point { x: 1, y: 0 };
    let p2 = Point { x: 2, y: 3 };

    let p3 = p1 + p2;

    println!("{:?}", p3);
}

在main中，我们可以对我们的两个Point用+号，因为我们已经为Point实现了Add<Output=Point>。

有一系列可以这样被重载的运算符，并且所有与之相关的trait都在std::ops模块中。查看它的文档来获取完整的列表。

实现这些特性要遵循一个模式。让我们仔细看看Add：

# mod foo {
pub trait Add<RHS = Self> {
    type Output;

    fn add(self, rhs: RHS) -> Self::Output;
}
# }

这里总共涉及到3个类型：你impl Add的类型，RHS，它默认是Self，和Output。对于一个表达式let z = x + y，x是Self类型的，y是RHS，而z是Self::Output类型。

# struct Point;
# use std::ops::Add;
impl Add<i32> for Point {
    type Output = f64;

    fn add(self, rhs: i32) -> f64 {
        // add an i32 to a Point and get an f64
# 1.0
    }
}

将允许你这样做：

let p: Point = // ...
let x: f64 = p + 2i32;

在泛型结构体中使用运算符 trait

现在我们知道了运算符 trait 是如何定义的了，我们可以更通用的定义来自trait 章节的HasArea trait 和Square结构体：

use std::ops::Mul;

trait HasArea<T> {
    fn area(&self) -> T;
}

struct Square<T> {
    x: T,
    y: T,
    side: T,
}

impl<T> HasArea<T> for Square<T>
        where T: Mul<Output=T> + Copy {
    fn area(&self) -> T {
        self.side * self.side
    }
}

fn main() {
    let s = Square {
        x: 0.0f64,
        y: 0.0f64,
        side: 12.0f64,
    };

    println!("Area of s: {}", s.area());
}

对于HasArea和Square，我们声明了一个类型参数T并取代f64。impl则需要更深入的修改：

impl<T> HasArea<T> for Square<T>
        where T: Mul<Output=T> + Copy { ... }

area方法要求我们可以进行边的乘法，所以我们声明的T类型必须实现std::ops::Mul。比如上面提到的Add，Mul自身获取一个Output参数：因为我们知道相乘时数字并不会改变类型，我也设定它为T。T也必须支持拷贝，所以 Rust 并不尝试将self.side移动进返回值。