Sobrecarga de operadores en Rust

Los operadores son traits: implementa Add y + funciona en tu tipo.

use std::ops::{Add, AddAssign};

#[derive(Debug, Clone, Copy)]
struct Vec2 {
    x: f64,
    y: f64,
}

impl Add for Vec2 {
    type Output = Vec2;

    fn add(self, other: Vec2) -> Vec2 {
        Vec2 { x: self.x + other.x, y: self.y + other.y }
    }
}

impl AddAssign for Vec2 {
    fn add_assign(&mut self, other: Vec2) {
        self.x += other.x;
        self.y += other.y;
    }
}

fn main() {
    let a = Vec2 { x: 1.0, y: 2.0 };
    let b = Vec2 { x: 0.5, y: 0.5 };
    println!("{:?}", a + b);

    let mut total = a;
    total += b;
    println!("{:?}", total);
}

Cómo funciona

1. std::ops::Add tiene un tipo asociado Output.
2. AddAssign te da la forma +=.
3. Implementa un operador solo cuando el significado es obvio.

Palabras clave y builtins usados aquí

• f64
• fn
• for
• impl
• let
• mut
• self
• struct
• type
• use

El intento, en números

Líneas

32

Caracteres a escribir

498

Tokens

175

Ritmo de tres estrellas

105 tpm

Al ritmo de tres estrellas de 105 tokens por minuto, este intento toma unos 100 segundos.

Escribe este fragmento

Paso 1 de 4 en Operadores y acceso; paso 12 de 19 en Traits y genéricos.

← Anterior Siguiente →