Menu do sistema
O programa deve permitir ao usuário escolher uma opção do menu. Ao selecionar a opção 1, o programa deve solicitar ao usuário que insira um caractere para ser adicionado à pilha. Ao selecionar a opção 2, o programa deve remover o último caractere adicionado à pilha e exibi-lo na tela. Caso a pilha esteja vazia, o programa deve informar ao usuário que a pilha está vazia. A opção 3 deve encerrar o programa.
Ao final de cada operação (adição ou remoção), o programa deve exibir o conteúdo atual da pilha.
Dica: Para c++, utilize a estrutura de dados stack
da biblioteca padrão do C++ para implementar a pilha.
Neste exercício, podemos aprender sobre o uso de pilhas e como implementar um programa simples que utiliza essa estrutura de dados. Além disso, podemos aprender sobre:
Interatividade do usuário: O exercício envolve a interação do usuário com o programa por meio de um menu de opções. Isso nos permite entender como criar interfaces simples para interagir com o usuário.
Manipulação de pilhas: A implementação do programa envolve a manipulação de uma pilha de caracteres, incluindo adição e remoção de elementos. Isso nos permite entender como trabalhar com pilhas na prática e entender seus métodos básicos, como push
e pop
.
Tratamento de erros: O programa lida com casos em que a pilha está vazia ao tentar remover um elemento. Isso nos ensina sobre como lidar com situações de erro e fornecer feedback adequado ao usuário.
Estrutura de repetição: O uso do loop do-while
permite que o programa continue executando até que o usuário escolha a opção de saída. Isso nos ajuda a entender como criar estruturas de repetição controladas por usuário.
Organização do código: O código está estruturado de forma organizada, com funções separadas para diferentes funcionalidades, como impressão da pilha e manipulação do menu. Isso nos ensina sobre boas práticas de organização e modularização do código.
Vamos aos códigos!
/****************************************************************************** Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br *******************************************************************************/ #include <iostream> #include <stack> using namespace std; void imprimePilha(stack<char> pilha) { cout << "-------" << endl; while (!pilha.empty()) { cout << "| " << pilha.top() << " |" << endl; cout << "-------" << endl; pilha.pop(); } } int main() { stack<char> pilha; int opcao; do { cout << "\nSelecione uma opção:\n"; cout << "1. Adicionar item\n"; cout << "2. Remover item\n"; cout << "3. Sair\n"; cout << "Opção: "; cin >> opcao; switch (opcao) { case 1: char item; cout << "Digite o item a ser adicionado: "; cin >> item; pilha.push(item); cout << "Item adicionado!" << endl; break; case 2: if (pilha.empty()) { cout << "Pilha vazia!" << endl; } else { char elementoRemovido = pilha.top(); pilha.pop(); cout << "Item removido: " << elementoRemovido << endl; } break; case 3: cout << "Saindo..." << endl; break; default: cout << "Opção inválida!" << endl; } imprimePilha(pilha); } while (opcao != 3); return 0; }
O programa implementa um menu para manipulação de uma pilha de caracteres em C++. As opções permitem adicionar e remover elementos da pilha, com validação para pilha vazia. O código utiliza um loop do-while
para interação contínua com o usuário e uma função para imprimir visualmente a pilha.
/****************************************************************************** Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br *******************************************************************************/ use std::collections::LinkedList; use std::io::{self, Write}; fn imprime_pilha(pilha: &LinkedList<char>) { println!("-------"); for item in pilha.iter().rev() { println!("| {} |", item); println!("-------"); } } fn main() { let mut pilha: LinkedList<char> = LinkedList::new(); let mut opcao: i32; loop { println!("\nSelecione uma opção:"); println!("1. Adicionar item"); println!("2. Remover item"); println!("3. Sair"); print!("Opção: "); io::stdout().flush().unwrap(); let mut input = String::new(); io::stdin().read_line(&mut input).expect("Falha ao ler a entrada"); opcao = input.trim().parse().expect("Entrada inválida"); match opcao { 1 => { print!("Digite o item a ser adicionado: "); io::stdout().flush().unwrap(); let mut input = String::new(); io::stdin().read_line(&mut input).expect("Falha ao ler a entrada"); let item = input.trim().chars().next().expect("Entrada inválida"); pilha.push_front(item); println!("Item adicionado!"); }, 2 => { match pilha.pop_front() { Some(item) => println!("Item removido: {}", item), None => println!("Pilha vazia!"), } }, 3 => { println!("Saindo..."); break; }, _ => println!("Opção inválida!"), } imprime_pilha(&pilha); } }
Este código em Rust utiliza a estrutura de dados LinkedList
para representar a pilha. Ele apresenta um menu de opções ao usuário e permite adicionar e remover itens da pilha, além de sair do programa quando desejado.
/****************************************************************************** Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br *******************************************************************************/ package main import ( "container/list" "fmt" "os" "os/exec" ) func clearScreen() { cmd := exec.Command("cmd", "/c", "cls") cmd.Stdout = os.Stdout cmd.Run() } func imprimePilha(pilha *list.List) { clearScreen() fmt.Println("-------") for e := pilha.Front(); e != nil; e = e.Next() { fmt.Printf("| %c |\n", e.Value) fmt.Println("-------") } } func main() { pilha := list.New() for { fmt.Println("\nSelecione uma opção:") fmt.Println("1. Adicionar item") fmt.Println("2. Remover item") fmt.Println("3. Sair") fmt.Print("Opção: ") var opcao int fmt.Scanln(&opcao) switch opcao { case 1: var item rune fmt.Print("Digite o item a ser adicionado: ") fmt.Scanf("%c\n", &item) pilha.PushFront(item) fmt.Println("Item adicionado!") case 2: if pilha.Len() == 0 { fmt.Println("Pilha vazia!") } else { item := pilha.Remove(pilha.Front()) fmt.Printf("Item removido: %c\n", item) } case 3: fmt.Println("Saindo...") return default: fmt.Println("Opção inválida!") } imprimePilha(pilha) } }
Este código em Go realiza as mesmas operações que o programa em C++, utilizando a estrutura de dados list.List
da biblioteca padrão. Ele apresenta um menu de opções ao usuário e permite adicionar e remover itens da pilha, além de sair do programa quando desejado. A função imprimePilha
é responsável por exibir a pilha visualmente no console.
Este exercício proporcionou uma oportunidade valiosa de explorar a implementação de uma estrutura de dados fundamental, como uma pilha, em diferentes linguagens de programação. Além disso, pude destacar a importância de compreender os recursos e as bibliotecas disponíveis em cada linguagem para implementar soluções eficazes. Este exercício reforçou a compreensão dos conceitos fundamentais de programação e a habilidade de adaptar esses conceitos a diferentes ambientes de desenvolvimento.
Beleza pessoal? Espero que tenham gostado.
Dívidas ou sugestões? Deixe o seu comentário!
Um abraço e até o próximo post. Valeu!
#Programação
#EstruturaDeDados
#DesafioDeProgramação
#GiovaniDaCruz
Está gostando do conteúdo?
Considere pagar um cafezinho para nossa equipe!