Resumen - Punto de coordenadas

Parte de la sección Programación Orientada a Objetos del Journey de Rust de Coddy. Lección 28 de 61.

Desafío

Fácil

¡Construyamos un sistema de coordenadas flexible que funcione con cualquier tipo numérico! Crearás una estructura genérica Point que puede representar posiciones usando enteros para juegos basados en cuadrículas o números de punto flotante para gráficos precisos: todo a partir de una sola definición.

Organizarás tu código en dos archivos:

point.rs: Define una estructura pública genérica Point<T> con dos campos públicos: x y y, ambos de tipo T. Implementa métodos para tu punto:
- Una función asociada new que crea un punto a partir de las coordenadas x e y
- Un método translate que recibe valores dx y dy y devuelve un nuevo Point con las coordenadas desplazadas en esas cantidades (esto requiere que T admita la suma y la copia, así que usa el límite T: std::ops::Add<Output = T> + Copy)
main.rs: Incorpora tu módulo de puntos y demuestra cómo la misma estructura genérica funciona sin problemas con distintos tipos numéricos.

En tu archivo principal, muestra tu Point genérico de la siguiente manera:

Crea un punto entero usando las dos primeras entradas (interpretadas como i32)
Trasládalo usando la tercera y cuarta entradas (también i32)
Crea un punto de punto flotante usando la quinta y sexta entradas (interpretadas como f64)
Muestra los tres puntos

Tu salida debe seguir este formato:

Integer point: ({x}, {y})
After translation: ({x}, {y})
Float point: ({x}, {y})

Por ejemplo, con las entradas 3, 5, 2, -1, 1.5 y 2.5:

Integer point: (3, 5)
After translation: (5, 4)
Float point: (1.5, 2.5)

Observa cómo Point::new(3, 5) crea un Point<i32>, mientras que Point::new(1.5, 2.5) crea un Point<f64>: ¡la misma definición de estructura se adapta a ambos!

Recibirás seis entradas: dos enteros para el primer punto, dos enteros para la traslación y dos números de punto flotante para el segundo punto.

Pruébalo tú mismo

mod point;

use point::Point;

fn main() {
    // Leer entradas
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let x1: i32 = input.trim().parse().expect("Invalid input");
    
    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let y1: i32 = input.trim().parse().expect("Invalid input");
    
    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let dx: i32 = input.trim().parse().expect("Invalid input");
    
    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let dy: i32 = input.trim().parse().expect("Invalid input");
    
    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let x2: f64 = input.trim().parse().expect("Invalid input");
    
    input.clear();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let y2: f64 = input.trim().parse().expect("Invalid input");
    
    // TODO: Create an integer point using x1 and y1
    
    // TODO: Translate the integer point by dx and dy
    
    // TODO: Crea un punto de coma flotante usando x2 y y2
    
    // TODO: Imprime los resultados en el formato requerido:
    // println!("Integer point: ({}, {})", ...);
    // println!("After translation: ({}, {})", ...);
    // println!("Float point: ({}, {})", ...);
}