Перевантаження операторів

У Rust багато операторів можна перевантажити за допомогою trait-ів. Тобто деякі оператори можна використовувати для виконання різних завдань залежно від їхніх вхідних аргументів. Це можливо, тому що оператори є синтаксичним цукром для викликів методів. Наприклад, оператор + у a + b викликає метод add (як у a.add(b)). Цей метод add є частиною trait-у Add. Отже, оператор + може використовуватися будь-яким реалізатором trait-у Add.

Перелік trait-ів, таких як Add, що перевантажують оператори, можна знайти в core::ops.

use std::ops;

struct Foo;
struct Bar;

#[derive(Debug)]
struct FooBar;

#[derive(Debug)]
struct BarFoo;

// The `std::ops::Add` trait is used to specify the functionality of `+`.
// Here, we make `Add<Bar>` - the trait for addition with a RHS of type `Bar`.
// The following block implements the operation: Foo + Bar = FooBar
impl ops::Add<Bar> for Foo {
    type Output = FooBar;

    fn add(self, _rhs: Bar) -> FooBar {
        println!("> Foo.add(Bar) was called");

        FooBar
    }
}

// By reversing the types, we end up implementing non-commutative addition.
// Here, we make `Add<Foo>` - the trait for addition with a RHS of type `Foo`.
// This block implements the operation: Bar + Foo = BarFoo
impl ops::Add<Foo> for Bar {
    type Output = BarFoo;

    fn add(self, _rhs: Foo) -> BarFoo {
        println!("> Bar.add(Foo) was called");

        BarFoo
    }
}

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

Див. також

Add, Syntax Index