Zusammenfassung - Koordinatenpunkt

Teil des Abschnitts Object Oriented Programming der Rust-Journey von Coddy. Lektion 28 von 61.

Aufgabe

Einfach

Lass uns ein flexibles Koordinatensystem erstellen, das mit jedem numerischen Typ funktioniert! Du erstellst eine generische Point-struct, die Positionen mit Integern für rasterbasierte Spiele oder floating-point-Zahlen für präzise Grafiken darstellen kann – alles aus einer einzigen Definition.

Du organisierst deinen Code über zwei Dateien:

point.rs: Define eine public generische Point<T>-struct mit zwei public fields: x und y, beide vom Typ T. Implementiere methods für deinen point:
- Eine new associated function, die einen point aus x- und y-Koordinaten erstellt
- Eine translate-method, die dx- und dy-Werte entgegennimmt und einen neuen Point zurückgibt, dessen Koordinaten um diese Werte verschoben sind (dies requires, dass T addition und copying support, also verwende den bound T: std::ops::Add<Output = T> + Copy)
main.rs: Binde dein point-Modul ein und zeige, wie dieselbe generische struct nahtlos mit unterschiedlichen numerischen Typen funktioniert.

Zeige in deiner main-Datei deine generische Point-struct, indem du:

einen Integer-point mit den ersten beiden inputs erstellst (als i32 geparst)
ihn um die dritten und vierten inputs verschiebst (ebenfalls i32)
einen floating-point-point mit den fünften und sechsten inputs erstellst (als f64 geparst)
alle drei points anzeigst

Deine Ausgabe sollte diesem format folgen:

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

Wenn die inputs beispielsweise 3, 5, 2, -1, 1.5 und 2.5 lauten:

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

Beachte, wie Point::new(3, 5) einen Point<i32> erstellt, während Point::new(1.5, 2.5) einen Point<f64> erstellt: Dieselbe struct-Definition passt sich an beide an!

Du erhältst sechs inputs: zwei Integer für den ersten point, zwei Integer für die Verschiebung und zwei floats für den zweiten point.

Probier es selbst

mod point;

use point::Point;

fn main() {
    // Eingaben lesen
    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: Erstelle einen Gleitkomma-Punkt mit x2 und y2
    
    // TODO: Gib die Ergebnisse im erforderlichen Format aus:
    // println!("Integer point: ({}, {})", ...);
    // println!("After translation: ({}, {})", ...);
    // println!("Float point: ({}, {})", ...);
}