VisualG Programa que armazena valores em uma pilha

[Lorenzo Nunez]

Olá, estou tentando desenvolver um programa que armazene valores do tipo inteiro em uma pilha de dados, porém estou com dificuldades pois a função de tipo logico (cheia e vazia) não retornam o valor esperado, criando um problema na hora de informar se a pilha está cheia ou vazia.

Algoritmo "Modulo10Ex4Pilha"
// Disciplina  : Algoritmos
// Professor   : Livro Algoritmos
// Descrição   : Excercios do Livro
// Autor(a)    : Lorenzo Nunez
// Data atual  : 11/11/2022
Const
   lim = 4
Var
// Seção de Declarações das variáveis 
   pilha: vetor [1..lim] de inteiro
   topo: inteiro
   op, i: inteiro

Funcao vazia: logico
Var
   vazia: logico
Inicio
   se (topo = 0) então
      vazia <- verdadeiro
   senao
      vazia <- falso
   fimse
Fimfuncao

Funcao cheia: logico
Var
   cheia: logico
Inicio
   se (topo = lim) então
      cheia <- verdadeiro
   senao
      cheia <- falso
   fimse
Fimfuncao

Funcao adicionar (elemento: inteiro): logico
Var
   adicionar: logico
Inicio
   se (cheia) então
      adicionar <- falso
   senao
      topo <- topo + 1
      pilha[topo] <- elemento
      adicionar <- verdadeiro
   fimse
Fimfuncao

Funcao retirar (elemento: inteiro): logico
Var
   retirar: logico
Inicio
   se (vazia) então
      retirar <- falso
   senao
      elemento <- pilha[topo]
      pilha[topo] <- 0
      topo <- topo - 1
      retirar <- verdadeiro
   fimse
Fimfuncao

Procedimento empilhar()
Var
   x: inteiro
Inicio
   leia(x)
   se (adicionar(x)) então
      escreval("O elemento", x," foi adicionado na posição",topo,"º")
   senao
      escreval("impossível adicionar o elemento",x," - Pilha Cheia!")
   fimse
Fimprocedimento

Procedimento desempilhar()
Var
   x: inteiro
Inicio
   se (retirar(x)) então
      escreval("O elemento", x," foi retirado do topo da pilha")
   senao
      escreval("impossível retirar o elemento", x," - Pilha Vazia!")
   fimse
Fimprocedimento

Procedimento mostrar()
Var
   i: inteiro
Inicio
   se (vazia) então
      escreval("impossível apresentar - Pilha Vaiza!")
   senao
      para i de topo ate 1 passo -1 faca
         escreval("Posição: ",i,"º = ", pilha[i])
      fimpara
   fimse
Fimprocedimento

Procedimento criar(var pilha: inteiro)
Var
   i: inteiro
Inicio
   topo <- 0
   para i de 1 ate lim faca
      pilha[i] <- 0
   fimpara
Fimprocedimento

Inicio
// Seção de Comandos, procedimento, funções, operadores, etc... 
   para i de 1 ate lim faca
      criar(pilha[i])
   fimpara
   op <- 0
   enquanto (op <> 5) faca
      escreval("[1] - Empilhar")
      escreval("[2] - Desempilhar")
      escreval("[3] - Aprensentar")
      escreval("[4] - Criar pilha")
      escreval("[5] - Sair")
      leia(op)
      limpatela
      se (op <= 5) então
         escolha op
         caso 1
            empilhar()
         caso 2
            desempilhar()
         caso 3
            mostrar()
         caso 4
            para i de 1 ate lim faca
               criar(pilha[i])
            fimpara
         outrocaso
            escreval("Bye!")
         fimescolha
      fimse
   fimenquanto
   
Fimalgoritmo

 

[devair1010]

@Lorenzo Nunez    notei que você não colocou  o comando para retornar um valor qualquer , e assim é , sem o "rotorne" não retorna nada . e fica lá na função .

Funcao vazia: logico   /// creio que variavel com mesmo nome
Var                    /// da funcao dara interferencia
   vazilha: logico
Inicio
   se (topo = 0) então
      vazilha <- verdadeiro
   senao
      vazilha <- falso
   fimse
   retorne vazilha
Fimfuncao

 

[Simon Viegas]

Basicamente está declarando as funções com uma sintaxe errada. Vejam um exemplo de como deveria ser aqui: https://www.apoioinformatica.inf.br/produtos/item/18-funcoes

 

Resumidamente: no VisualG, o retorno é pelo comando retorne (Ex.: retorne VERDADEIRO) . Diferente do Pascal (pai do VisualG), onde o retorno é na própria função mesmo. (Ex.: vazia := true).

 

Para ajudar a identificar melhor, remova o limpaTela() e veja que já dá problema na hora de empilhar.

 

Exemplo para o Adicionar():

funcao Adicionar (elemento: inteiro) : logico
inicio
   se (Cheia()) então
      retorne FALSO
   senao
      topo <- topo + 1
      pilha[topo] <- elemento
      retorne VERDADEIRO
   fimSe
fimFuncao

 

Exemplo para o Cheia():

funcao Cheia() : logico
inicio
   se (topo >= LIM) então
      retorne VERDADEIRO
   senao
      retorne FALSO
   fimse
fimFuncao

 

Por aí vai.

 

[Lorenzo Nunez]

Muito obrigado pela ajuda, vocês são incríveis. 

[Simon Viegas]

ADENDO: o comando retorne no VisualG não finaliza o fluxo da função, ou seja, o programa continua seguindo o fluxo normalmente até chegar no fimFuncao. Nas maiorias das principais linguagens de programação, como javascript, existe o comando análogo return... este sim já finaliza, ou seja, ao executar o return, seria como se automaticamente também já executasse o "fimFuncao".

 

O que isso muda?

 

Se o VisualG "fosse como os outros", poderia fazer algo assim:

 

funcao Adicionar (elemento: inteiro) : logico
inicio
   se (Cheia()) então
      retorne FALSO //não vai funcionar corretamente, pois vai continuar
                    //e acabar retornando o VERDADEIRO lá de baixo
   fimSe
  
   topo <- topo + 1
   pilha[topo] <- elemento
   retorne VERDADEIRO
fimFuncao

 

Entende? Ali no topo, seria como uma "regra de validação". Se tiver cheia, iria executar o retorno, e a função iria já finalizar... Fica mais simples e elegante. Se não tiver cheia, vai pular e continuar normalmente...

 

Para testar, vá pressionando F8... e acompanhando linha a linha o que está sendo executado...

 

ADENDO 2: não! Você não pode colocar um fimFuncao dentro do se. Algo como:

 

funcao Adicionar (elemento: inteiro) : logico
inicio
   se (Cheia()) então
      retorne FALSO
      fimFuncao //não pode fazer isso!
   fimSe
  
   topo <- topo + 1
   pilha[topo] <- elemento
   retorne VERDADEIRO
fimFuncao

 

 

 

ADENDO 3: da mesma forma... NÃO! NÃO PODE colocar fimAlgoritmo em qualquer outra parte do código. Se fizer isso, vai rodar, pois o VisualG é problemático e o código meio que é "interpretado". (Não tem um mecanismo de compilação para apontar o erro.)