Exercício: pilha de caracteres com menu de opções
Menu do sistema
- Adicionar item à pilha.
- Remover item da pilha.
- Sair do programa.
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.
O que podemos aprender neste exercício?
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!
Exemplo em C++
/******************************************************************************
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.
Exemplo em Rust
/******************************************************************************
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.
Exemplo em Go
/******************************************************************************
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.
Conclusão
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
