Rust
Opérateurs et surcharge

Introduction

Surcharger l'opérateur d'addition (+)

La surcharge de l'opérateur d'addition (+) nécessite l'implémentation du trait std::ops::Add .

À partir de la documentation, la définition complète du trait est la suivante:

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

Comment ça marche?

• le trait est implémenté pour le type côté gauche
• le trait est implémenté pour un argument du côté droit, sauf s'il est spécifié qu'il a le même type que le côté gauche
• le type du résultat de l'addition est spécifié dans le type associé de Output

Ainsi, avoir 3 types différents est possible.

Remarque: le trait consomme des arguments de gauche et de droite, vous préférerez peut-être l'implémenter pour des références à votre type plutôt qu'aux types dénudés.

Implémenter + pour un type personnalisé:

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