Rust
Operators en overbelasting

Invoering

Overbelasting van de opteloperator (+)

Overbelasting van de opteloperator (+) vereist implementeren van de std::ops::Add eigenschap std::ops::Add .

Uit de documentatie is de volledige definitie van de eigenschap:

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

Hoe werkt het?

• de eigenschap is geïmplementeerd voor het type Linkerzijde
• de eigenschap is geïmplementeerd voor één argument aan de rechterkant, tenzij gespecificeerd, heeft het standaard hetzelfde type als het argument aan de linkerkant
• het type resultaat van de toevoeging is opgegeven in het bijbehorende type Output

Er zijn dus 3 verschillende typen mogelijk.

Opmerking: de eigenschap die wordt gebruikt is argumenten aan de linkerkant en aan de rechterkant, u kunt de voorkeur geven aan het implementeren van verwijzingen naar uw type in plaats van de blote typen.

+ Implementeren voor een aangepast type:

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