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.