Rust
Operatorzy i przeładowanie

Wprowadzenie

Przeciążenie operatora dodawania (+)

Przeciążenie operatora dodawania (+) wymaga implementacji cechy std::ops::Add .

Z dokumentacji pełna definicja cechy to:

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

Jak to działa?

• cecha jest zaimplementowana dla typu Lewa strona
• cecha jest implementowana dla jednego argumentu po prawej stronie, chyba że określono, że domyślnie ma ten sam typ, co argument po lewej stronie
• typ wyniku dodania jest określony w powiązanym typie Output

Zatem możliwe są 3 różne typy.

Uwaga: cecha, którą zużywa, to argumenty po lewej i po prawej stronie, możesz raczej zaimplementować ją dla odniesień do twojego typu niż dla samych typów.

Implementowanie + dla niestandardowego typu:

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