Récapitulatif - Point de coordonnées

Fait partie de la section Object Oriented Programming du Journey Rust de Coddy. Leçon 28 sur 61.

Défi

Facile

Construisons un système de coordonnées flexible qui fonctionne avec n'importe quel type numérique ! Vous allez créer une structure générique Point capable de représenter des positions en utilisant des entiers pour des jeux basés sur une grille ou des nombres à virgule flottante pour des graphismes précis — le tout à partir d'une seule définition.

Vous organiserez votre code sur deux fichiers :

point.rs : Définissez une structure générique publique Point<T> avec deux champs publics : x et y, tous deux de type T. Implémentez des méthodes pour votre point :
- Une fonction associée new qui crée un point à partir des coordonnées x et y
- Une méthode translate qui prend des valeurs dx et dy et retourne un nouveau Point avec les coordonnées décalées de ces montants (cela nécessite que T supporte l'addition et la copie, utilisez donc la contrainte T: std::ops::Add<Output = T> + Copy)
main.rs : Importez votre module point et démontrez comment la même structure générique fonctionne parfaitement avec différents types numériques.

Dans votre fichier principal, mettez en valeur votre Point générique en :

Créant un point entier en utilisant les deux premières entrées (analysées comme i32)
Le translatant par les troisième et quatrième entrées (également i32)
Créant un point à virgule flottante en utilisant les cinquième et sixième entrées (analysées comme f64)
Affichant les trois points

Votre sortie doit suivre ce format :

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

Par exemple, avec les entrées 3, 5, 2, -1, 1.5, et 2.5 :

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

Remarquez comment Point::new(3, 5) crée un Point<i32> tandis que Point::new(1.5, 2.5) crée un Point<f64> — la même définition de structure s'adapte aux deux !

Vous recevrez six entrées : deux entiers pour le premier point, deux entiers pour la translation, et deux flottants pour le second point.

Essayez vous-même

mod point;

use point::Point;

fn main() {
    // Lire les entrées
    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: Créer un point entier en utilisant x1 et y1
    
    // TODO: Effectuer une translation du point entier par dx et dy
    
    // TODO: Créer un point à virgule flottante en utilisant x2 et y2
    
    // TODO: Afficher les résultats au format requis :
    // println!("Integer point: ({}, {})", ...);
    // println!("After translation: ({}, {})", ...);
    // println!("Float point: ({}, {})", ...);
}