Structures mutables

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

Par défaut, les instances de struct en Rust sont immuables - une fois que vous les avez créées, vous ne pouvez pas modifier les valeurs de leurs champs. Cependant, tout comme pour les autres variables, vous pouvez rendre une instance de struct mutable en ajoutant le mot-clé mut lors de sa déclaration.

Lorsque vous déclarez une instance de structure comme mutable, vous pouvez modifier n'importe lequel de ses champs en utilisant la notation par point :

let mut player = Player {
    name: String::from("Alice"),
    score: 0,
};

player.score = 100; // Cela fonctionne car player est mutable

Sans le mot-clé mut, tenter de modifier un champ entraînerait une erreur de compilation. La mutabilité s'applique à l'instance entière de la structure — vous ne pouvez pas rendre certains champs individuels mutables tout en gardant les autres immuables.

Défi

Facile

Vous recevrez quatre entrées : un nom de joueur, un score initial (sous forme d'entier), un score bonus à ajouter (sous forme d'entier) et un ajustement de score final (sous forme d'entier). Définissez une structure Player avec deux champs : name de type String et score de type i32. Créez une instance mutable de cette structure, puis modifiez le champ score plusieurs fois en utilisant les valeurs d'entrée.

Exigences :

Définir une structure Player avec les champs : name: String et score: i32
Lire la première entrée comme nom du joueur
Lire la deuxième entrée et la convertir en i32 pour le score initial
Créer une instance mutable de la structure Player avec ces valeurs
Lire la troisième entrée et la convertir en i32 pour le score bonus
Ajouter le score bonus au score actuel du joueur en utilisant la notation par point
Lire la quatrième entrée et la convertir en i32 pour l'ajustement final
Ajouter l'ajustement final au score actuel du joueur
Afficher les informations du joueur dans le format exact indiqué ci-dessous

Entrée :

Première ligne : Nom du joueur (par ex., Alice)
Deuxième ligne : Score initial sous forme d'entier (par ex., 50)
Troisième ligne : Score bonus sous forme d'entier (par ex., 30)
Quatrième ligne : Ajustement final sous forme d'entier (par ex., 20)

Sortie :

Première ligne : Player: [name]
Deuxième ligne : Final Score: [score]

Aide-mémoire

Les instances de structures en Rust sont immuables par défaut. Pour modifier les valeurs des champs après la création, déclarez l'instance comme mutable en utilisant le mot-clé mut :

let mut player = Player {
    name: String::from("Alice"),
    score: 0,
};

player.score = 100; // Modifier le champ en utilisant la notation par point

La mutabilité s'applique à l'ensemble de l'instance de la structure - vous ne pouvez pas rendre certains champs individuels mutables tout en gardant les autres immuables.

Essayez vous-même

use std::io;

// TODO: Définir la structure Player ici avec les champs name et score

fn main() {
    // Lire le nom du joueur
    let mut name = String::new();
    io::stdin().read_line(&mut name).expect("Failed to read line");
    let name = name.trim().to_string();
    
    // Lire le score initial
    let mut initial_score = String::new();
    io::stdin().read_line(&mut initial_score).expect("Failed to read line");
    let initial_score: i32 = initial_score.trim().parse().expect("Invalid number");
    
    // Lire le score bonus
    let mut bonus = String::new();
    io::stdin().read_line(&mut bonus).expect("Failed to read line");
    let bonus: i32 = bonus.trim().parse().expect("Invalid number");
    
    // Lire l'ajustement final
    let mut adjustment = String::new();
    io::stdin().read_line(&mut adjustment).expect("Failed to read line");
    let adjustment: i32 = adjustment.trim().parse().expect("Invalid number");
    
    // TODO: Créer une instance mutable de Player
    
    // TODO: Ajouter le score bonus au score du joueur
    
    // TODO: Ajouter l'ajustement final au score du joueur
    
    // TODO: Afficher la sortie au format requis
}