Recapitulação - Ponto de Coordenada

Parte da seção Object Oriented Programming do Journey de Rust da Coddy — lição 28 de 61.

Desafio

Fácil

Vamos construir um sistema de coordenadas flexível que funcione com qualquer tipo numérico! Você criará uma struct Point genérica 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 Point<T> genérica pública com dois campos públicos: x e y, ambos do tipo T. Implemente métodos para o 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 suporte adição e cópia, portanto use a restrição T: std::ops::Add<Output = T> + Copy)
main.rs: Importe seu módulo point 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)
Traduzindo-o pela terceira e quarta entradas (também i32)
Criando um ponto de ponto flutuante usando a quinta e sexta entradas (analisadas como f64)
Exibindo todos 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 a tradução e dois floats para o segundo ponto.

Experimente você mesmo

mod point;

use point::Point;

fn main() {
    // Ler as 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: Criar um ponto inteiro usando x1 e y1
    
    // TODO: Transladar o ponto inteiro por dx e 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: ({}, {})", ...);
}