Rust
Operatori e sovraccarico

introduzione

Sovraccarico dell'operatore di addizione (+)

Il sovraccarico dell'operatore di addizione (+) richiede l'implementazione di std::ops::Add trait.

Dalla documentazione, la definizione completa del tratto è:

pub trait Add<RHS = Self> {
    type Output;
    fn add(self, rhs: RHS) -> Self::Output;
}

Come funziona?

• il tratto è implementato per il tipo di mano sinistra
• il tratto è implementato per un argomento sul lato destro, a meno che specificato non abbia lo stesso tipo di quello del lato sinistro
• il tipo del risultato dell'aggiunta è specificato nel tipo associato Output

Quindi, è possibile avere 3 tipi diversi.

Nota: il tratto consuma argomenti sul lato sinistro e sul lato destro, potresti preferire implementarlo per i riferimenti al tuo tipo piuttosto che per i tipi nudi.

Implementazione + per un tipo personalizzato:

use std::ops::Add;

#[derive(Clone)]
struct List<T> {
    data: Vec<T>,
}
//  Implementation which consumes both LHS and RHS
impl<T> Add for List<T> {
    type Output = List<T>;

    fn add(self, rhs: List<T>) -> List<T> {
        self.data.extend(rhs.data.drain(..));
        self
    }
}

//  Implementation which only consumes RHS (and thus where LHS != RHS)
impl<'a, T: Clone> Add<List<T>> for &'a List<T> {
    type Output = List<T>;

    fn add(self, rhs: List<T>) -> List<T> {
        self.clone() + rhs
    }
}