Ripasso - Punto di coordinate

Fa parte della sezione Programmazione orientata agli oggetti del percorso Rust di Coddy. Lezione 28 di 61.

Sfida

Facile

Costruiamo un sistema di coordinate flessibile che funziona con qualsiasi tipo numerico! Creerai una struct generica Point che può rappresentare posizioni usando interi per giochi basati su griglia o numeri in virgola mobile per grafica precisa: tutto da un’unica definizione.

Organizzerai il codice in due file:

point.rs: definisci una struct generica pubblica Point<T> con due campi pubblici: x e y, entrambi di tipo T. Implementa i metodi per il tuo punto:
- Una funzione associata new che crea un punto a partire dalle coordinate x e y
- Un metodo translate che accetta i valori dx e dy e restituisce un nuovo Point con le coordinate traslate di tali quantità (ciò richiede che T supporti l’addizione e la copia, quindi usa il vincolo T: std::ops::Add<Output = T> + Copy)
main.rs: importa il tuo modulo point e mostra come la stessa struct generica funziona senza problemi con diversi tipi numerici.

Nel tuo file principale, mostra la tua Point generica:

Creando un punto intero usando i primi due input (analizzati come i32)
Traslandolo usando il terzo e il quarto input (anch’essi i32)
Creando un punto in virgola mobile usando il quinto e il sesto input (analizzati come f64)
Visualizzando tutti e tre i punti

L’output deve seguire questo formato:

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

Per esempio, con gli input 3, 5, 2, -1, 1.5 e 2.5:

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

Nota come Point::new(3, 5) crea un Point<i32>, mentre Point::new(1.5, 2.5) crea un Point<f64>: la stessa definizione di struct si adatta a entrambi!

Riceverai sei input: due interi per il primo punto, due interi per la traslazione e due numeri in virgola mobile per il secondo punto.

Provalo tu

mod point;

use point::Point;

fn main() {
    // Leggi gli input
    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: Crea un punto a coordinate intere usando x1 e y1
    
    // TODO: Trasla il punto a coordinate intere di dx e dy
    
    // TODO: Crea un punto a coordinate in virgola mobile usando x2 e y2
    
    // TODO: Stampa i risultati nel formato richiesto:
    // println!("Integer point: ({}, {})", ...);
    // println!("After translation: ({}, {})", ...);
    // println!("Float point: ({}, {})", ...);
}