Pile générique

Fait partie de la section Programmation Orientée Objet du Journey Rust de Coddy. Leçon 59 sur 61.

Défi

Facile

Une pile est une structure de données fondamentale qui suit le principe « Last In, First Out » (LIFO) : le dernier élément ajouté est le premier retiré. Imagine une pile d’assiettes : tu ajoutes les assiettes par le haut et tu les retires par le haut.

Construisons une structure de données générique Stack pouvant contenir n’importe quel type d’élément ! Une pile suit le principe « Last In, First Out », comme une pile de livres dans laquelle tu peux uniquement ajouter ou retirer des éléments par le haut.

Tu vas organiser ton code dans deux fichiers :

stack.rs : définis ta structure Stack<T> générique, qui utilise en interne un Vec<T> pour stocker les éléments. Implémente trois méthodes : new pour créer une pile vide, push pour ajouter un élément au sommet, et pop pour retirer et renvoyer l’élément au sommet (en renvoyant Option<T>, puisque la pile peut être vide).
main.rs : importe ton module de pile et montre le fonctionnement de ta Stack avec des entiers. Crée une pile, ajoute-y les nombres fournis, puis retire les éléments et affiche chacun d’eux. Utilise unwrap_or pour gérer le Option renvoyé par pop ; si la pile est vide, utilise -1 comme valeur par défaut.

Une pile a besoin de deux opérations essentielles :

push : ajoute un élément au sommet de la pile
pop : retire et renvoie l’élément au sommet

La méthode pop doit renvoyer un Option<T>, puisque la pile peut être vide. Le type Vec possède déjà une méthode pop qui renvoie un Option<T>, et tu peux l’utiliser dans ton implémentation.

Ta pile doit fonctionner ainsi : lorsque tu ajoutes les valeurs 10, 20 et 30 (dans cet ordre), trois retraits successifs doivent renvoyer 30, 20 et 10 (dans l’ordre inverse). Un quatrième retrait sur une pile vide doit renvoyer la valeur par défaut.

Affiche chaque valeur retirée sur sa propre ligne :

Par exemple, avec les entrées 5, 15 et 25 :

Tu recevras trois entrées : trois entiers à ajouter à la pile (analyse chacun comme un i32). Après avoir ajouté les trois valeurs, retire des éléments quatre fois afin de montrer à la fois les retraits réussis et le cas où la pile est vide.

Essayez vous-même

mod stack;

use stack::Stack;

fn main() {
    // Lire trois entiers depuis l'entrée
    let mut input1 = String::new();
    std::io::stdin().read_line(&mut input1).expect("Failed to read line");
    let num1: i32 = input1.trim().parse().expect("Invalid number");

    let mut input2 = String::new();
    std::io::stdin().read_line(&mut input2).expect("Failed to read line");
    let num2: i32 = input2.trim().parse().expect("Invalid number");

    let mut input3 = String::new();
    std::io::stdin().read_line(&mut input3).expect("Failed to read line");
    let num3: i32 = input3.trim().parse().expect("Invalid number");

    // TODO: Créer une nouvelle Stack

    // TODO: Empiler les trois nombres sur la pile (num1, num2, num3 dans cet ordre)

    // TODO: Dépiler quatre fois et afficher chaque résultat
    // Utiliser unwrap_or(-1) pour gérer le cas de la pile vide
}