Pila genérica

Parte de la sección Programación Orientada a Objetos del Journey de Rust de Coddy. Lección 59 de 61.

Desafío

Fácil

Una pila es una estructura de datos fundamental que sigue el principio «Last In, First Out» (LIFO): el último elemento añadido es el primero que se elimina. Piensa en una pila de platos: añades platos por arriba y los retiras por arriba.

¡Construyamos una estructura de datos genérica Stack que pueda contener cualquier tipo de elemento! Una pila sigue el principio «Last In, First Out», como una pila de libros en la que solo puedes añadir o retirar elementos por arriba.

Organizarás tu código en dos archivos:

stack.rs: Define tu estructura genérica Stack<T>, que utiliza internamente un Vec<T> para almacenar elementos. Implementa tres métodos: new para crear una pila vacía, push para añadir un elemento arriba y pop para eliminar y devolver el elemento superior (devolviendo Option<T>, ya que la pila podría estar vacía).
main.rs: Incluye tu módulo de pila y demuestra el funcionamiento de tu Stack con enteros. Crea una pila, añade los números proporcionados y después extrae los elementos e imprime cada uno. Usa unwrap_or para gestionar el Option devuelto por pop; si la pila está vacía, usa -1 como valor predeterminado.

Una pila necesita dos operaciones esenciales:

push: añade un elemento arriba de la pila
pop: elimina y devuelve el elemento superior

El método pop debe devolver un Option<T>, ya que la pila podría estar vacía. El tipo Vec ya tiene un método pop que devuelve Option<T>, y puedes aprovecharlo en tu implementación.

Tu pila debería funcionar así: cuando añades los valores 10, 20 y 30 (en ese orden), extraer elementos tres veces debería darte 30, 20 y 10 (en orden inverso). Una cuarta extracción en una pila vacía debería devolver el valor predeterminado.

Imprime cada valor extraído en su propia línea:

Por ejemplo, con las entradas 5, 15 y 25:

Recibirás tres entradas: tres enteros que debes añadir a la pila (convierte cada uno a i32). Después de añadir los tres, extrae elementos cuatro veces para demostrar tanto las extracciones exitosas como el caso de una pila vacía.

Pruébalo tú mismo

mod stack;

use stack::Stack;

fn main() {
    // Lee tres enteros de la entrada
    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: Crea un nuevo Stack

    // TODO: Empuja los tres números en la pila (num1, num2, num3 en ese orden)

    // TODO: Haz pop cuatro veces e imprime cada resultado
    // Usa unwrap_or(-1) para manejar el caso de la pila vacía
}