Zusammenfassung - Koordinatenpunkt

Teil des Abschnitts Objektorientierte Programmierung der Rust-Journey von Coddy. Lektion 28 von 61.

Aufgabe

Einfach

Erstellen wir ein flexibles Koordinatensystem, das mit jedem numerischen Typ funktioniert! Du erstellst eine generische Point-Struktur, die Positionen mithilfe von Ganzzahlen für rasterbasierte Spiele oder Gleitkommazahlen für präzise Grafiken darstellen kann – alles aus einer einzigen Definition.

Du organisierst deinen Code über zwei Dateien:

point.rs: Definiere eine öffentliche generische Point<T>-Struktur mit zwei öffentlichen Feldern: x und y, beide vom Typ T. Implementiere Methoden für deinen Punkt:
- Eine zugehörige new-Funktion, die aus x- und y-Koordinaten einen Punkt erstellt
- Eine translate-Methode, die dx- und dy-Werte übernimmt und einen neuen Point zurückgibt, dessen Koordinaten um diese Werte verschoben wurden (dafür muss T Addition und Kopieren unterstützen, verwende also die Einschränkung T: std::ops::Add<Output = T> + Copy)
main.rs: Binde dein Punktmodul ein und zeige, wie dieselbe generische Struktur nahtlos mit verschiedenen numerischen Typen funktioniert.

Präsentiere in deiner Hauptdatei deinen generischen Point, indem du:

einen Ganzzahlpunkt mithilfe der ersten beiden Eingaben erstellst (als i32 eingelesen)
ihn um die dritte und vierte Eingabe verschiebst (ebenfalls i32)
einen Gleitkommapunkt mithilfe der fünften und sechsten Eingabe erstellst (als f64 eingelesen)
alle drei Punkte ausgibst

Deine Ausgabe sollte diesem Format folgen:

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

Zum Beispiel bei den Eingaben 3, 5, 2, -1, 1.5 und 2.5:

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 Strukturdefinition passt sich an beide an!

Du erhältst sechs Eingaben: zwei Ganzzahlen für den ersten Punkt, zwei Ganzzahlen für die Verschiebung und zwei Gleitkommazahlen für den zweiten Punkt.

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: ({}, {})", ...);
}