Récapitulatif - Point de coordonnées

Fait partie de la section Programmation Orientée Objet 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 à l'aide d'entiers pour les jeux basés sur une grille ou de nombres à virgule flottante pour des graphiques précis : le tout à partir d'une seule définition.

Vous allez organiser 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 les valeurs dx et dy et renvoie un nouveau Point dont les coordonnées sont décalées de ces valeurs (cela nécessite que T prenne en charge l'addition et la copie, utilisez donc la contrainte T: std::ops::Add<Output = T> + Copy)
main.rs : Importez votre module de point et montrez comment la même structure générique fonctionne parfaitement avec différents types numériques.

Dans votre fichier principal, présentez votre Point générique en :

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

Votre sortie doit respecter 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 nombres à virgule flottante 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: Create an integer point using x1 and y1
    
    // TODO: Translate the integer point by dx and dy
    
    // TODO: Créer un point en virgule flottante en utilisant x2 et y2
    
    // TODO: Afficher les résultats dans le format requis :
    // println!("Integer point: ({}, {})", ...);
    // println!("After translation: ({}, {})", ...);
    // println!("Float point: ({}, {})", ...);
}