Pilha Genérica

Parte da seção Programação Orientada a Objetos do Journey de Rust da Coddy. Lição 59 de 61.

Desafio

Fácil

Uma stack é uma estrutura de dados fundamental que segue o princípio "Last In, First Out" (LIFO): o último item adicionado é o primeiro a ser removido. Pense em uma pilha de pratos: você adiciona pratos no topo e os remove do topo.

Vamos criar uma estrutura de dados genérica Stack que pode armazenar qualquer tipo de elemento! Uma stack segue o princípio "Last In, First Out", como uma pilha de livros na qual você só pode adicionar ou remover itens do topo.

Você organizará seu código em dois arquivos:

stack.rs: defina sua struct genérica Stack<T>, que usa internamente um Vec<T> para armazenar elementos. Implemente três métodos: new para criar uma stack vazia, push para adicionar um elemento ao topo e pop para remover e retornar o elemento do topo (retornando Option<T>, pois a stack pode estar vazia).
main.rs: inclua seu módulo de stack e demonstre o funcionamento da sua Stack com inteiros. Crie uma stack, use push para adicionar os números fornecidos a ela e, em seguida, use pop para remover os elementos e imprimir cada um. Use unwrap_or para lidar com o Option retornado por pop; se a stack estiver vazia, use -1 como valor padrão.

Uma stack precisa de duas operações essenciais:

push: adiciona um elemento ao topo da stack
pop: remove e retorna o elemento do topo

O método pop deve retornar um Option<T>, pois a stack pode estar vazia. O tipo Vec já possui um método pop que retorna Option<T>, e você pode aproveitá-lo na sua implementação.

Sua stack deve funcionar assim: quando você usa push nos valores 10, 20 e 30 (nessa ordem), usar pop três vezes deve fornecer 30, 20 e 10 (na ordem inversa). Um quarto pop em uma stack vazia deve retornar o valor padrão.

Imprima cada valor removido em sua própria linha:

Por exemplo, com as entradas 5, 15 e 25:

Você receberá três entradas: três inteiros para adicionar à stack (converta cada um para i32). Depois de adicionar os três, use pop quatro vezes para demonstrar tanto as remoções bem-sucedidas quanto o caso de stack vazia.

Experimente você mesmo

mod stack;

use stack::Stack;

fn main() {
    // Leia três inteiros da 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: Crie uma nova Stack

    // TODO: Empilhe os três números na stack (num1, num2, num3 nessa ordem)

    // TODO: Desempilhe quatro vezes e imprima cada resultado
    // Use unwrap_or(-1) para lidar com o caso de stack vazia
}