Les structures comme paramètres de fonction

Fait partie de la section Logic & Flow du Journey Rust de Coddy — leçon 24 sur 66.

Maintenant que vous savez comment créer et modifier des structures, explorons comment les utiliser avec des fonctions. Tout comme n'importe quel autre type de données en Rust, vous pouvez passer des instances de structures à des fonctions et les retourner à partir de fonctions.

Pour passer une structure à une fonction, il suffit de l'inclure comme paramètre dans la définition de la fonction :

fn calculate_area(rect: Rectangle) -> i32 {
    rect.width * rect.height
}

Cette fonction prend une structure Rectangle en tant que paramètre et retourne un i32. À l'intérieur de la fonction, vous pouvez accéder aux champs de la structure en utilisant la notation par point, tout comme vous le feriez n'importe où ailleurs.

Vous pouvez également retourner des structures à partir de fonctions en spécifiant le type de structure comme type de retour :

fn create_square(size: i32) -> Rectangle {
    Rectangle {
        width: size,
        height: size,
    }
}

L'utilisation de structures avec des fonctions rend votre code plus organisé et significatif. Au lieu de passer plusieurs paramètres individuels, vous pouvez regrouper les données associées et les transmettre comme une seule unité bien définie.

Défi

Facile

Vous recevrez quatre entrées : la largeur d'un rectangle (sous forme d'entier), la hauteur d'un rectangle (sous forme d'entier), la longueur du côté d'un carré (sous forme d'entier) et un numéro de choix (1 ou 2). Définissez une structure Rectangle avec deux champs : width: i32 et height: i32. Créez deux fonctions : une qui prend un Rectangle et calcule son aire, et une autre qui prend une longueur de côté et retourne un Rectangle représentant un carré. En fonction de l'entrée de choix, calculez et affichez l'aire appropriée.

Exigences :

Définir une structure Rectangle avec les champs : width: i32 et height: i32
Créer une fonction calculate_area qui prend un Rectangle en paramètre et retourne un i32 (l'aire)
Créer une fonction create_square qui prend un i32 (longueur du côté) en paramètre et retourne un Rectangle avec une largeur et une hauteur égales
Lire la première entrée et la convertir en i32 pour la largeur du rectangle
Lire la deuxième entrée et la convertir en i32 pour la hauteur du rectangle
Créer une instance de Rectangle avec ces dimensions
Lire la troisième entrée et la convertir en i32 pour la longueur du côté du carré
Lire la quatrième entrée et la convertir en i32 pour le choix (1 ou 2)
Si le choix est 1 : calculer et afficher l'aire du rectangle
Si le choix est 2 : créer un carré en utilisant create_square, puis calculer et afficher son aire

Entrée :

Première ligne : Largeur du rectangle sous forme d'entier (par ex., 8)
Deuxième ligne : Hauteur du rectangle sous forme d'entier (par ex., 5)
Troisième ligne : Longueur du côté du carré sous forme d'entier (par ex., 6)
Quatrième ligne : Choix sous forme d'entier, soit 1 ou 2 (par ex., 1)

Sortie :

Si le choix est 1 : Rectangle area: [area]
Si le choix est 2 : Square area: [area]

Aide-mémoire

Les structures peuvent être passées aux fonctions en tant que paramètres et retournées par les fonctions.

Pour passer une structure à une fonction, incluez-la en tant que paramètre :

fn calculate_area(rect: Rectangle) -> i32 {
    rect.width * rect.height
}

Pour retourner une structure depuis une fonction, spécifiez le type de la structure comme type de retour :

fn create_square(size: i32) -> Rectangle {
    Rectangle {
        width: size,
        height: size,
    }
}

À l'intérieur des fonctions, accédez aux champs de la structure en utilisant la notation par point. L'utilisation de structures avec des fonctions vous permet de regrouper des données liées ensemble au lieu de passer plusieurs paramètres individuels.

Essayez vous-même

use std::io;

// TODO: Définir la structure Rectangle ici


// TODO: Définir la fonction calculate_area ici


// TODO: Définir la fonction create_square ici


fn main() {
    // Lire la largeur du rectangle
    let mut width_input = String::new();
    io::stdin().read_line(&mut width_input).expect("Failed to read line");
    let width: i32 = width_input.trim().parse().expect("Invalid input");
    
    // Lire la hauteur du rectangle
    let mut height_input = String::new();
    io::stdin().read_line(&mut height_input).expect("Failed to read line");
    let height: i32 = height_input.trim().parse().expect("Invalid input");
    
    // Lire la longueur du côté du carré
    let mut side_input = String::new();
    io::stdin().read_line(&mut side_input).expect("Failed to read line");
    let side: i32 = side_input.trim().parse().expect("Invalid input");
    
    // Lire le choix
    let mut choice_input = String::new();
    io::stdin().read_line(&mut choice_input).expect("Failed to read line");
    let choice: i32 = choice_input.trim().parse().expect("Invalid input");
    
    // TODO: Écrire votre code ci-dessous
    // Créer une instance de Rectangle, vérifier le choix, et calculer l'aire appropriée
    
    
    // Afficher le résultat en fonction du choix
    // Utiliser : println!("Rectangle area: {}", area); ou println!("Square area: {}", area);
}