Operadores

A sobrecarga de operadores é implementada por meio do trait contido em std::ops:

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

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

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

fn main() {
    let p1 = Point { x: 10, y: 20 };
    let p2 = Point { x: 100, y: 200 };
    println!("{:?} + {:?} = {:?}", p1, p2, p1 + p2);
}
This slide should take about 5 minutes.

Pontos de discussão:

  • Você pode implementar Add para &Point. Em quais situações isso é útil?
    • Resposta: Add:add consome self. Se o tipo T para o qual você está sobrecarregando o operador não implementa Copy, você deve considerar sobrecarregar o operador para &T também. Isso evita a clonagem desnecessária no local da chamada.
  • Por que Output é um tipo associado? Poderia ser feito um parâmetro de tipo do método?
    • Resposta curta: os parâmetros de tipo de função são controlados pelo chamador, mas os tipos associados (como Output) são controlados pelo implementador de um trait.
  • Você pode implementar Add para dois tipos diferentes, por exemplo, impl Add<(i32, i32)> for Point adicionaria uma tupla a um Point.