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.

Keyboard shortcuts

Comprehensive Rust 🦀

Operadores