Pile générique

Fait partie de la section Object Oriented Programming du Journey Rust de Coddy — leçon 59 sur 61.

Défi

Facile

Une pile (stack) est une structure de données fondamentale qui suit le principe "Dernier Entré, Premier Sorti" (LIFO) — le dernier élément ajouté est le premier à être retiré. Pensez à une pile d'assiettes : vous ajoutez des assiettes sur le dessus et vous les retirez par le dessus.

Construisons une structure de données Stack générique capable de contenir n'importe quel type d'élément ! Une pile suit le principe "Dernier Entré, Premier Sorti" — comme une pile de livres où vous ne pouvez ajouter ou retirer que par le haut.

Vous organiserez votre code sur deux fichiers :

stack.rs : Définissez votre structure générique Stack<T> qui utilise un Vec<T> en interne pour stocker les éléments. Implémentez 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 supérieur (renvoyant Option<T> puisque la pile peut être vide).
main.rs : Importez votre module stack et démontrez le fonctionnement de votre Stack avec des entiers. Créez une pile, poussez les nombres fournis dessus, puis retirez les éléments et affichez chacun d'eux. Utilisez unwrap_or pour gérer l'Option renvoyée par pop — si la pile est vide, utilisez -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 supérieur

La méthode pop doit renvoyer un Option<T> car la pile peut être vide. Le type Vec possède déjà une méthode pop qui renvoie Option<T>, que vous pouvez exploiter dans votre implémentation.

Votre pile devrait fonctionner ainsi : lorsque vous poussez les valeurs 10, 20 et 30 (dans cet ordre), retirer trois fois devrait vous donner 30, 20 et 10 (ordre inverse). Un quatrième retrait sur une pile vide devrait renvoyer la valeur par défaut.

Affichez chaque valeur retirée sur sa propre ligne :

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

Vous recevrez trois entrées : trois entiers à pousser sur la pile (analysez chacun comme un i32). Après avoir poussé les trois, retirez quatre fois pour démontrer à la fois les retraits réussis et le cas de la pile 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 d'une pile vide
}