En esta entrada usaremos el mismo archivo de la entrada anterior. Vamos a implementar los métodos del "trait" OpsVector2d que creamos en la entrada pasada. Para imprimir los valores ponemos "#[derive(Debug)]" en los lugares correspondientes en struct Vector2d y en el enum ModuloDeVector.
El elemento más importante a agregar es un bloque denotado con la clave "impl". Dentro de este bloque tenemos que escribir la firma de la función y escribir el código de la función correspondiente. La función debe regresar el tipo de dato requerido por el "trait". El bloque impl define la implementación trait para un struct y la sintaxis es "impl <trait> for <struct>". Imprimimos los valores de las funciones con diferentes entradas para probarlas.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 | #[derive(Debug)] struct Vector2d { x: i32, y: i32 } #[derive(Debug)] enum ModuloDeVector { MayorAUno, ExactamenteUno, MenorAUno } trait OpsVector2d { fn modulo_comparado_con_uno(&self) -> ModuloDeVector; fn igualdad(&self, v2: &Vector2d) -> bool; fn producto_punto(&self, v2: &Vector2d) -> i32; fn suma(&self, v2: &Vector2d) -> Vector2d; fn producto_escalar(&self, escalar: i32) -> Vector2d; } fn producto_punto_y_luego_escalar( entrada1: &impl OpsVector2d, entrada2: &Vector2d) -> Vector2d { let resultado1 = entrada1.producto_punto(entrada2); entrada1.producto_escalar(resultado1) } impl OpsVector2d for Vector2d { fn modulo_comparado_con_uno(&self) -> ModuloDeVector { let modulo_al_cuadrado = (self.x * self.x) + (self.y * self.y); if modulo_al_cuadrado > 1 { ModuloDeVector::MayorAUno } else if modulo_al_cuadrado < 1 { ModuloDeVector::MenorAUno } else { ModuloDeVector::ExactamenteUno } } fn igualdad(&self, v2: &Vector2d) -> bool { if self.x == v2.x && self.y == v2.y { true } else { false } } fn producto_punto(&self, v2: &Vector2d) -> i32 { (self.x * v2.x) + (self.y * v2.y) } fn suma(&self, v2: &Vector2d) -> Vector2d { Vector2d { x:self.x + v2.x, y:self.y + v2.y } } fn producto_escalar(&self, escalar: i32) -> Vector2d { Vector2d { x:self.x * escalar, y:self.y * escalar } } } fn main() { let mi_vector1: Vector2d = Vector2d { x: 2, y: 3}; let mi_vector2: Vector2d = Vector2d { x: 1, y: 0}; let mi_vector3: Vector2d = Vector2d { x: 0, y: 0}; println!("modulo_comparado_con_uno1 : {:?}", mi_vector1.modulo_comparado_con_uno()); println!("modulo_comparado_con_uno2 : {:?}", mi_vector2.modulo_comparado_con_uno()); println!("modulo_comparado_con_uno3 : {:?}", mi_vector3.modulo_comparado_con_uno()); println!("igualdad1 : {:?}", mi_vector1.igualdad(&mi_vector1)); println!("igualdad2 : {:?}", mi_vector1.igualdad(&mi_vector2)); println!("suma1 : {:?}", mi_vector1.suma(&mi_vector2)); println!("suma2 : {:?}", mi_vector2.suma(&mi_vector3)); println!("suma3 : {:?}", mi_vector1.suma(&mi_vector3)); println!("producto_escalar1 : {:?}", mi_vector1.producto_escalar(2)); println!("producto_escalar2 : {:?}", mi_vector2.producto_escalar(-1)); println!("producto_escalar3 : {:?}", mi_vector1.producto_escalar(3)); println!("producto_escalar4 : {:?}", mi_vector1.producto_escalar(-4)); println!("producto_punto1 : {:?}", mi_vector1.producto_punto(&mi_vector2)); println!("producto_punto2 : {:?}", mi_vector1.producto_punto(&mi_vector1)); println!("producto_punto_y_luego_escalar1 : {:?}", producto_punto_y_luego_escalar(&mi_vector1, &mi_vector2)); println!("producto_punto_y_luego_escalar2 : {:?}", producto_punto_y_luego_escalar(&mi_vector2, &mi_vector1)); println!("producto_punto_y_luego_escalar3 : {:?}", producto_punto_y_luego_escalar(&mi_vector1, &mi_vector3)); println!("'Trait' definido, implementado y usado"); } |
El resultado del código es el siguiente:
- The Rust Book - Traits : Defining Shared Behavior https://doc.rust-lang.org/book/ch10-02-traits.html
No hay comentarios.:
Publicar un comentario