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