Rust
Operatörer och överbelastning

Introduktion

Överbelastning av tilläggsoperatören (+)

Överbelastning av tilläggsoperatören (+) kräver implementering av std::ops::Add egenskap.

Från dokumentationen är den fulla definitionen av egenskaperna:

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

Hur fungerar det?

• Egenskapen är implementerad för vänster sida
• Egenskapen implementeras för ett argument på höger sida, såvida det inte anges att det är standard att ha samma typ som vänsterhand ett
• typen av resultatet av tillägget anges i den tillhörande typen Output

Således är det möjligt att ha 3 olika typer.

Obs! Egenskapen konsumerar är vänster- och högersidesargument, du kanske föredrar att implementera det för referenser till din typ snarare än bara typer.

Implementera + för en anpassad typ:

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
    }
}