Recapitulação - Ponto de Coordenada

Parte da seção Programação Orientada a Objetos do Journey de Rust da Coddy. Lição 28 de 61.

Desafio

Fácil

Vamos criar um sistema de coordenadas flexível que funcione com qualquer tipo numérico! Você criará uma struct genérica Point que pode representar posições usando inteiros para jogos baseados em grade ou números de ponto flutuante para gráficos precisos: tudo a partir de uma única definição.

Você organizará seu código em dois arquivos:

point.rs: Defina uma struct genérica pública Point<T> com dois campos públicos: x e y, ambos do tipo T. Implemente métodos para seu ponto:
- Uma função associada new que cria um ponto a partir das coordenadas x e y
- Um método translate que recebe valores dx e dy e retorna um novo Point com as coordenadas deslocadas por esses valores (isso exige que T ofereça suporte à adição e à cópia; portanto, use o limite T: std::ops::Add<Output = T> + Copy)
main.rs: Inclua seu módulo de ponto e demonstre como a mesma struct genérica funciona perfeitamente com diferentes tipos numéricos.

No seu arquivo principal, demonstre seu Point genérico:

Criando um ponto inteiro usando as duas primeiras entradas (analisadas como i32)
Deslocando-o pelas terceira e quarta entradas (também i32)
Criando um ponto de ponto flutuante usando a quinta e a sexta entradas (analisadas como f64)
Exibindo os três pontos

Sua saída deve seguir este formato:

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

Por exemplo, com as entradas 3, 5, 2, -1, 1.5 e 2.5:

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

Observe como Point::new(3, 5) cria um Point<i32>, enquanto Point::new(1.5, 2.5) cria um Point<f64>: a mesma definição de struct se adapta a ambos!

Você receberá seis entradas: dois inteiros para o primeiro ponto, dois inteiros para o deslocamento e dois números de ponto flutuante para o segundo ponto.

Experimente você mesmo

mod point;

use point::Point;

fn main() {
    // Ler 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: Criar um ponto de ponto flutuante usando x2 e y2
    
    // TODO: Imprimir os resultados no formato exigido:
    // println!("Integer point: ({}, {})", ...);
    // println!("After translation: ({}, {})", ...);
    // println!("Float point: ({}, {})", ...);
}