Surchargement d'opérateurs en Rust

Introduction

Dans ce laboratoire, nous explorons le surchargement d'opérateurs en Rust et comment il peut être réalisé grâce à des traits. Les opérateurs en Rust peuvent être surchargés à l'aide de traits, ce qui leur permet d'effectuer différentes tâches en fonction de leurs arguments d'entrée. L'opérateur +, par exemple, est un sucre syntaxique pour la méthode add et peut être utilisé par tout implémentateur du trait Add. Les traits qui surchargent les opérateurs, y compris Add, se trouvent dans core::ops. Le code Rust fourni montre comment surcharger l'opérateur + pour les types personnalisés Foo et Bar, donnant respectivement des types de sortie différents FooBar et BarFoo.

Note : Si le laboratoire ne spécifie pas de nom de fichier, vous pouvez utiliser n'importe quel nom de fichier que vous voulez. Par exemple, vous pouvez utiliser main.rs, le compiler et l'exécuter avec rustc main.rs &&./main.

Surchargement d'opérateurs

En Rust, de nombreux opérateurs peuvent être surchargés via des traits. C'est-à-dire que certains opérateurs peuvent être utilisés pour accomplir différentes tâches en fonction de leurs arguments d'entrée. Cela est possible car les opérateurs sont du sucre syntaxique pour les appels de méthodes. Par exemple, l'opérateur + dans a + b appelle la méthode add (comme dans a.add(b)). Cette méthode add est partie du trait Add. Par conséquent, l'opérateur + peut être utilisé par tout implémentateur du trait Add.

Une liste des traits, tels que Add, qui surchargent les opérateurs peut être trouvée dans core::ops.

use std::ops;

struct Foo;
struct Bar;

#[derive(Debug)]
struct FooBar;

#[derive(Debug)]
struct BarFoo;

// Le trait `std::ops::Add` est utilisé pour spécifier la fonctionnalité de `+`.
// Ici, nous définissons `Add<Bar>` - le trait pour l'addition avec un opérande droit de type `Bar`.
// Le bloc suivant implémente l'opération : Foo + Bar = FooBar
impl ops::Add<Bar> for Foo {
    type Output = FooBar;

    fn add(self, _rhs: Bar) -> FooBar {
        println!("> Foo.add(Bar) a été appelé");

        FooBar
    }
}

// En inversant les types, nous finissons par implémenter une addition non commutative.
// Ici, nous définissons `Add<Foo>` - le trait pour l'addition avec un opérande droit de type `Foo`.
// Ce bloc implémente l'opération : Bar + Foo = BarFoo
impl ops::Add<Foo> for Bar {
    type Output = BarFoo;

    fn add(self, _rhs: Foo) -> BarFoo {
        println!("> Bar.add(Foo) a été appelé");

        BarFoo
    }
}

fn main() {
    println!("Foo + Bar = {:?}", Foo + Bar);
    println!("Bar + Foo = {:?}", Bar + Foo);
}

Sommaire

Félicitations ! Vous avez terminé le laboratoire sur le surchargement d'opérateurs. Vous pouvez pratiquer d'autres laboratoires dans LabEx pour améliorer vos compétences.