運算符與重載

operators-and-overloading.md
commit 6ba952020fbc91bad64be1ea0650bfba52e6aab4

Rust 允許有限形式的運算符重載。特定的運算符可以被重載。要支持一個類型間特定的運算符，你可以實現(xiàn)一個的特定的重載運算符的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用+號，因為我們已經(jīng)為Point實現(xiàn)了Add<Output=Point>。

有一系列可以這樣被重載的運算符，并且所有與之相關(guān)的trait都在std::ops模塊中。查看它的文檔來獲取完整的列表。

實現(xiàn)這些特性要遵循一個模式。讓我們仔細看看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;

在泛型結(jié)構(gòu)體中使用運算符 trait

現(xiàn)在我們知道了運算符 trait 是如何定義的了，我們可以更通用的定義來自[trait 章節(jié)]()的HasArea trait 和Square結(jié)構(gòu)體：

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，我們聲明了一個類型參數(shù)T并取代f64。impl則需要更深入的修改：

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

area方法要求我們可以進行邊的乘法，所以我們聲明的T類型必須實現(xiàn)std::ops::Mul。比如上面提到的Add，Mul自身獲取一個Output參數(shù)：因為我們知道相乘時數(shù)字并不會改變類型，我也設(shè)定它為T。T也必須支持拷貝，所以 Rust 并不嘗試將self.side移動進返回值。