Resumen - Punto de coordenadas

Parte de la sección Object Oriented Programming del Journey de Rust de Coddy — lección 28 de 61.

Desafío

Fácil

¡Vamos a construir un sistema de coordenadas flexible que funcione con cualquier tipo numérico! Crearás una estructura Point genérica que pueda representar posiciones usando enteros para juegos basados en cuadrículas o números de punto flotante para gráficos precisos, todo desde una única 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 e 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 toma valores dx y dy y devuelve un nuevo Point con las coordenadas desplazadas por esas cantidades (esto requiere que T admita la adición y el copiado, así que usa el límite T: std::ops::Add<Output = T> + Copy)
main.rs: Importa tu módulo point y demuestra cómo la misma estructura genérica funciona sin problemas con diferentes tipos numéricos.

En tu archivo principal, muestra tu Point genérico mediante:

La creación de un punto entero usando las dos primeras entradas (analizadas como i32)
Su traslación mediante la tercera y cuarta entrada (también i32)
La creación de un punto de punto flotante usando la quinta y sexta entrada (analizadas como f64)
La visualización de 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 flotantes 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: Crear un punto entero usando x1 e y1
    
    // TODO: Trasladar el punto entero por dx y dy
    
    // TODO: Crear un punto de punto flotante usando x2 e y2
    
    // TODO: Imprimir los resultados en el formato requerido:
    // println!("Integer point: ({}, {})", ...);
    // println!("After translation: ({}, {})", ...);
    // println!("Float point: ({}, {})", ...);
}