Sobrecarga de Operadores em Rust

Introdução

Neste laboratório, exploramos a sobrecarga de operadores em Rust e como ela pode ser alcançada através de traits. Operadores em Rust podem ser sobrecarregados usando traits, o que lhes permite realizar diferentes tarefas com base em seus argumentos de entrada. O operador +, por exemplo, é açúcar sintático (syntactic sugar) para o método add e pode ser usado por qualquer implementador da trait Add. As traits que sobrecarregam operadores, incluindo Add, podem ser encontradas em core::ops. O código Rust fornecido demonstra como sobrecarregar o operador + para os tipos personalizados Foo e Bar, resultando em diferentes tipos de saída FooBar e BarFoo, respectivamente.

Nota: Se o laboratório não especificar um nome de arquivo, você pode usar qualquer nome de arquivo que desejar. Por exemplo, você pode usar main.rs, compilar e executá-lo com rustc main.rs && ./main.

Sobrecarga de Operadores

Em Rust, muitos dos operadores podem ser sobrecarregados via traits. Ou seja, alguns operadores podem ser usados para realizar diferentes tarefas com base em seus argumentos de entrada. Isso é possível porque os operadores são açúcar sintático (syntactic sugar) para chamadas de métodos. Por exemplo, o operador + em a + b chama o método add (como em a.add(b)). Este método add faz parte da trait Add. Portanto, o operador + pode ser usado por qualquer implementador da trait Add.

Uma lista das traits, como Add, que sobrecarregam operadores pode ser encontrada em core::ops.

use std::ops;

struct Foo;
struct Bar;

#[derive(Debug)]
struct FooBar;

#[derive(Debug)]
struct BarFoo;

// A trait `std::ops::Add` é usada para especificar a funcionalidade de `+`.
// Aqui, fazemos `Add<Bar>` - a trait para adição com um RHS do tipo `Bar`.
// O bloco a seguir implementa a operação: 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
    }
}

// Ao inverter os tipos, acabamos implementando uma adição não comutativa.
// Aqui, fazemos `Add<Foo>` - a trait para adição com um RHS do tipo `Foo`.
// Este bloco implementa a operação: 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);
}

Resumo

Parabéns! Você concluiu o laboratório de Sobrecarga de Operadores. Você pode praticar mais laboratórios no LabEx para aprimorar suas habilidades.