VisualG Implementação de pilha Visualg

pablopccosta · 29 de março de 2021

Boa noite a todos!

Sei que esse assunto é recorrente aqui, e a própria atividade também.

Pesquisei por aqui, mas não encontrei uma atividade que seguisse a risca o que foi pedido. Estou tendo problemas com o menu dessa atividade. (Acredito que seja no menu.)

Está empilhando, listando e limpando, porém não está desempilhando e vazia (valor lógico - verdadeiro ou falso). Verdadeiro se a lista estiver vazia ou falso se não estiver.

Quando eu escolho a opção desempilhar e vazia retorna o seguinte erro: variável "..." não foi encontrada.

Poderiam me ajudar a entender esse problema? Desde já grato galera! Código abaixo! Qualquer problema encontrado no código fora esses me falem por favor.

Algoritmo "Implementação de Pilha-PC"
// Descrição   : SA4 - Atividade 1 Implementação de Pilha
// Autor(a)    : PC
// Data atual  : 15/3/2021

Var
   // Seção de Declarações das variáveis
   pilha:vetor[0..9] de caractere
   contNum: inteiro

   //Empilhar (adiciona um elemento no topo da pilha);
procedimento empilhar(nome:caractere)
inicio
   escreval(" Digite a letra que deseja empilhar:")
   leia(nome)
   pilha[topo]:= nome
   topo:= topo + 1

fimprocedimento

//Desempilhar (remove e retorna um elemento do topo da pilha);
funcao desempilhar(): caractere
var
   elemento: caractere

inicio
   elemento:= pilha[topo-1]
   pilha[topo-1]:= ""
   retorne elemento

fimfuncao

//Limpar (remove todos os elementos da pilha);
procedimento limpar()
var
   contNum: inteiro

inicio
   para contNum de 0 ate 9 faca
      pilha[contNum]:= ""
   fimpara
   topo:= 0

fimprocedimento

//Listar (lista todos os elementos armazenados na pilha);
procedimento listar()
var
   contNum: inteiro

inicio
   contNum:= contNum + 1
   para contNum de 0 ate 9 faca
      escreval(pilha[contNum])
      escreval(nome)
   fimpara

fimprocedimento

//Vazia (retorna verdadeiro se a pilha estiver vazia,
//falso caso contrário).
funcao vazia(): logico
var
   contNum: inteiro
   resp: logico

inicio
   resp:= verdadeiro
   para contNum de 0 ate 9 faca
      se nao (pilha[contNum]= "") entao
         resp:= falso
      fimse
   fimpara

   retorne resp

fimfuncao

topo: inteiro
op: inteiro
nome: caractere
inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   enquanto op <> 6 faca
      escreval("")
      escreval("-----------*IMPLEMENTAÇÃO DE PILHA*------------")
      escreval("")
      escreval("°1 Empilhar")
      escreval("°2 Desempilhar")
      escreval("°3 Limpar")
      escreval("°4 Listar")
      escreval("°5 Vazia")
      escreval("")
      escreval(" Digite a opção desejada:")
      leia(op)

      escolha op

      caso 1
         limpatela
         empilhar("")

      caso 2
         limpatela
         desempilhar()

      caso 3
         limpatela
         limpar()

      caso 4
         limpatela
         listar()

      caso 5
         limpatela
         vazia ()
         
      fimescolha
   fimenquanto

Fimalgoritmo

Simon Viegas · 29 de março de 2021

@pablopccosta, vamos lá:

1# Declaração das variáveis

Declare logo tudo lá em baixo... Exemplo:

var
   pilha: vetor[0..9] de caractere
   contNum: inteiro
   topo: inteiro
   op: inteiro
   nome: caractere
   
inicio
   enquanto op <> 6 faca
      escreval("")
      escreval("-----------*IMPLEMENTAÇÃO DE PILHA*------------")
      escreval("")

2# Estrutura das funções e procedimentos

De um modo simplificado, a orientação/sugestão é que tudo que uma função ou procedimento vai precisar, OU ela vai receber por parâmetro, OU ela tem dentro dela mesma... como no VisualG não é possível passar por parâmetro um vetor (por uma limitação técnica), pode/deve usar a variável global mesmo (não tem outro jeito). Já as coisas que dá para passar precisaria ou passar ou criar dentro da função. Veja:

Sobre:

Em 28/03/2021 às 21:03, pablopccosta disse:




//Empilhar (adiciona um elemento no topo da pilha);
procedimento Empilhar(nome: caractere)
inicio
   escreval(" Digite a letra que deseja empilhar:")
   leia(nome)
   pilha[topo]:= nome
   topo:= topo + 1
fimProcedimento

Aí você precisa se decidir:

OU você recebe o nome de fora e usa a função apenas para adicionar à pilha; (que seria o ideal, mas pode ler dentro também)

OU você você usa uma variável local (interna), lê a variável e, por fim, adiciona à pilha.

Não faz sentido usar esse parâmetro e ao mesmo tempo "substituir" lá dentro, sacou?

Para simplificar, por enquanto use assim mesmo:

//Adiciona um elemento no topo da pilha
procedimento Empilhar()
var
   nome: caractere
inicio
   escreval(" Digite o nome que deseja empilhar:")
   leia(nome)
   pilha[topo] <- nome
   topo <- topo + 1
fimProcedimento

Obs.: se for "letra" mesmo, mude a variável e o texto para "letra"... o que não pode é a variável ter um nomenclatura e o texto se referir a outra coisa. O código precisa sempre manter uma coerência.

3# Problema para chamar a função

Aqui eu também me bati para descobrir o que estava acontecendo, rs. Fiz alguns testes e consegui... Veja esse trecho:

Por ser uma função, por um motivo obscuro, o VisualG precisa que o retorno seja necessariamente usado... eu não entendi o porquê, só sei que é assim.

Pode fazer algo do tipo:

      caso 2
         limpaTela()
         nome <- Desempilhar()

ou assim:

      caso 2
         limpaTela()
         escreval(Desempilhar())

O importante que o valor retornado pela função seja "coletado" por algo.

Obs.: esse não é um comportamento comum. No Pascal, pai do VisualG, isso não ocorre! Seu código iria funcionar (nessa parte) normalmente. Em outras linguagens de programação a mesma coisa... "coletar" o retorno é geralmente facultativo.. aqui é preciso coletar, senão apresenta problemas a execução, como já visto (mas não deveria!).

4# Problema na função Desempilhar em si

falta antes verificar se está vazio ou não;
faltou atualizar o índice do vetor:
```
topo <- topo - 1
```
Da mesma forma que ele é atualizado com é empilhada, só que decrementando.

5# Problema na função Vazia()

Aqui você está verificando errado. O que especifica se uma pilhar está vazia ou não é o índice do vetor. Simplesmente você precisa verificar se o topo está igual ou não a 0 (ou algo do tipo). Daí, lembrar que lá no programa principal você necessariamente precisaria usar o retorno dessa função, ou seja: ela foi invocada para saber se a pilha está vazia ou não, correto? Daí precisa usar essa resposta...

Essa função será usada lá para desempilhar, já que não pode deixar tentar desempilhar uma pilha vazia. Talvez nem seja preciso deixar essa função lá no vetor. Se for necessário, coloque para exibir uma mensagem de acordo com a resposta da função.

ADENDO: lá em desempilhar, você nem precisa "apagar" o dado da posição.. isso é um trabalho desnecessário para o computador, basta atualizar o índice (topo).

***

Veja ponto a ponto o que sugeri... um a um... vá sempre tentando entender o que está ocorrendo e está fazendo.

Qualquer dúvida é só tentar novamente. Se não conseguir, tenta novamente... caso o problema persista, é só postar.

No aguardo.

pablopccosta · 31 de março de 2021

Muito obrigado meu camarada, deu uma luz p resolver essa atividade.

A respeito do "empilhar" escrevi conforme sua orientação, faz todo o sentido sua explicação. Declarei uma variável local "nome" para o procedimento "empilhar",

Em 29/03/2021 às 12:12, Simon Viegas disse:



//Adiciona um elemento no topo da pilha
procedimento Empilhar()
var
   nome: caractere
inicio
   escreval(" Digite o nome que deseja empilhar:")
   leia(nome)
   pilha[topo] <- nome
   topo <- topo + 1
fimProcedimento

porém, quando eu listava os valores, algumas letras apareciam repetidas (não entendi o por que) tive que voltar da forma antiga, chamando dentro também e usando a variável local. Imagino que seja um erro do VisualG mesmo.

A respeito do "desempilhar" usei um escreval para chamar a função como você disse e deu certo!

Para o "vazia" fiz da mesma forma colocando dentro do escreval. Deu certo também!

Após sua explicação abriu meu entendimento p conseguir finalizar essa atividade, mano, estava embaçado, 3 semanas quebrando a cabeça com isso.

Tive um problema na hora de "desempilhar". Não estava desempilhando o topo, mas mudei

Em 28/03/2021 às 21:03, pablopccosta disse:


inicio
   elemento := pilha[topo-1]
   pilha[topo-1] := ""
   retorne elemento
fimfuncao

inicio
   elemento := pilha[topo-1]
   pilha[topo-1] := ""
   topo := topo-1
   retorne elemento
fimfuncao

Eu estava usando o decremento no início, estava dando erro, reescrevi na terceira linha e deu certo.

Agradeço pela força brother! Salvou nessa atividade. Forte abraço a todos!

Algoritmo "Implementação de Pilha-PABLO"
// Descrição   : SA4 - Atividade 1 Implementação de Pilha
// Autor(a)    : Pablo
// Data atual  : 15/3/2021

Var
   // Seção de Declarações das variáveis
   pilha:vetor[0..9] de caractere
   contNum: inteiro

   //Empilhar (adiciona um elemento no topo da pilha);
procedimento empilhar(nome:caractere)
inicio
   escreval(" Digite a letra que deseja empilhar:")
   leia(nome)
   pilha[topo]:= nome
   topo:= topo + 1

fimprocedimento

//Desempilhar (remove e retorna um elemento do topo da pilha);
funcao desempilhar(): caractere
var
   elemento: caractere

inicio

   elemento:= pilha[topo-1]
   pilha[topo-1]:= ""
   topo:= topo-1
   retorne elemento

fimfuncao

//Limpar (remove todos os elementos da pilha);
procedimento limpar()
var
   contNum: inteiro

inicio
   para contNum de 0 ate 9 faca
      pilha[contNum]:= ""
   fimpara
   topo:= 0

fimprocedimento

//Listar (lista todos os elementos armazenados na pilha);
procedimento listar()
var
   contNum: inteiro

inicio
   contNum:= contNum + 1
   para contNum de 0 ate 9 faca
      escreval(pilha[contNum])
      escreval(nome)
   fimpara

fimprocedimento

//Vazia (retorna verdadeiro se a pilha estiver vazia,
//falso caso contrário).
funcao vazia(): logico
var
   contNum: inteiro
   resp: logico

inicio
   resp:= verdadeiro
   para contNum de 0 ate 9 faca
      se nao (pilha[contNum]= "") entao
         resp:= falso
      fimse
   fimpara

   retorne resp

fimfuncao

topo: inteiro
op: inteiro
nome: caractere
inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   enquanto op <> 6 faca
      escreval("")
      escreval("-----------*IMPLEMENTAÇÃO DE PILHA*------------")
      escreval("")
      escreval("°1 Empilhar")
      escreval("°2 Desempilhar")
      escreval("°3 Limpar")
      escreval("°4 Listar")
      escreval("°5 Vazia")
      escreval("")
      escreval(" Digite a opção desejada:")
      leia(op)

      escolha op

      caso 1
         limpatela
         empilhar("")

      caso 2
         limpatela
         escreval(desempilhar())

      caso 3
         limpatela
         limpar()

      caso 4
         limpatela
         listar()

      caso 5
         limpatela
         escreval(vazia ())

      fimescolha
   fimenquanto

Fimalgoritmo

Simon Viegas · 31 de março de 2021

Olá.

1# Uso incorreto de parâmetro + coerência entre texto e nomenclatura de variável

Sobre:

10 horas atrás, pablopccosta disse:


//Empilhar (adiciona um elemento no topo da pilha);
procedimento empilhar(nome:caractere)
inicio
   escreval(" Digite a letra que deseja empilhar:")
   leia(nome)
   pilha[topo]:= nome
   topo:= topo + 1
fimprocedimento

A dica continua: como não está recebendo nada pelo parâmetro, não tem porque ter parâmetro. Além disse o texto continuou com "letra".

Poderia ficar algo como:

//Adiciona um elemento no topo da pilha
procedimento Empilhar()
var
   nome: caractere
inicio
   escreval(" Digite a nome que deseja empilhar:")
   leia(nome)
   pilha[topo] <- nome
   topo <- topo + 1
fimProcedimento

      caso 1
         LimpaTela()
         Empilhar()

2# Lista apenas o que precisa listar

Sobre:

11 horas atrás, pablopccosta disse:


//Listar (lista todos os elementos armazenados na pilha);
procedimento listar()
var
   contNum: inteiro

inicio
   contNum:= contNum + 1
   para contNum de 0 ate 9 faca
      escreval(pilha[contNum])
      escreval(nome)
   fimpara

fimprocedimento

Você está sempre listando todo o vetor, o que não há necessidade. Outro ponto é que está utilizando a variável nome, que não tem qualquer relação com esse procedimento. Vide "orientação/sugestão":

Em 29/03/2021 às 12:12, Simon Viegas disse:

2# Estrutura das funções e procedimentos

De um modo simplificado, a orientação/sugestão é que tudo que uma função ou procedimento vai precisar, OU ela vai receber por parâmetro, OU ela tem dentro dela mesma...

Perceba que só de "absorver" esse conceito já dá para perceber que essa variável nome não deveria ser usado lá.

Segue um exemplo de como poderia ficar:

//Lista todos os elementos armazenados na pilha
procedimento Listar()
var
   i: inteiro
inicio
   para i de topo ate 0 passo -1 faca
      escreval(pilha[i])
   fimPara
fimProcedimento

Observe que é uma pilha... logo faz mais sentido exibir a lista de baixo para cima... "como uma pilha", por isso impresso de modo inverso (aparecer na tela corretamente). Ex.:

3# Sobre a definição e uso do Vazia()

Em 29/03/2021 às 12:12, Simon Viegas disse:

5# Problema na função Vazia()

Aqui você está verificando errado. O que especifica se uma pilhar está vazia ou não é o índice do vetor. Simplesmente você precisa verificar se o topo está igual ou não a 0 (ou algo do tipo). Daí, lembrar que lá no programa principal você necessariamente precisaria usar o retorno dessa função, ou seja: ela foi invocada para saber se a pilha está vazia ou não, correto? Daí precisa usar essa resposta...

Essa função será usada lá para desempilhar, já que não pode deixar tentar desempilhar uma pilha vazia. Talvez nem seja preciso deixar essa função lá no vetor. Se for necessário, coloque para exibir uma mensagem de acordo com a resposta da função.

Segue uma simplificação da função:

//Retorna VERDADEIRO se a pilha estiver vazia ou FALSO caso contrário
funcao Vazia(topo: inteiro): logico
inicio
   se topo = 0 entao
      retorne VERDADEIRO
   senao
      retorne FALSO
   fimSe
fimFuncao

***

Lá antes de desempilhar, você precisa antes verificar se a pilha não está vazia.

Da mesma forma, seria necessário criar uma função para verificar se está cheia, para antes de empilhar!

Efetue as correções e poste o código completo. Caso tenha tenha em alguma parte é só falar.

pablopccosta · 3 de abril de 2021

Boa noite Simon!

Entendi a necessidade de implementar essas funções para me retornar um alert caso queira inserir um valor maior do que descrito no vetor e se caso tentar desempilhar uma pilha vazia para ambos não retornarem erro como tem acontecido.

Não sei se estou verificando da forma certa, está faltando algo. Usei a função se, tanto para "empilhar" (se cheia) e para o "desempilhar" (se vazia), mas, quando a pilha fica cheia, me retorna a mensagem de "pilha cheia", em seguida coloco para listar e me retorna "erro".

Se "pilha vazia", me retorna a mensagem de "pilha vazia" e em baixo a primeira letra inserida na pilha. (Isso ta me deixando maluco já). Eu encerro o programa e inicio novamente, se eu testar o "listar" para testar e em seguida o desempilhar, aparece a última letra inserida na pilha da execução anterior do programa, mesmo depois de eu ter encerrado e iniciado novamente. Imagino que seja algum erro. (print em anexo).

A função "vazia" mudei conforme você orientou para simplificar mas está dando erro também. (print em anexo)

tenho impressão de que quando desempilho uma letra, o espaço da variável fica lá ainda, como se a linha estivesse ali ainda. Acredito que a ideia seja: Após desempilhar uma letra, a última ainda na pilha deve ocupar o topo, ou seja, a posição 0 do vetor.

O restante que orientou consegui implementar.

Mudei as "variáveis globais" para o final do código;

Criei uma "variável local" para a var letra, removendo-a do parâmetro do procedimento;

Se puder continuar tirando essas minhas dúvidas te agradeço.

Simon Viegas · 3 de abril de 2021

@pablopccosta, vamos lá:

Sobre:

14 horas atrás, pablopccosta disse:

Entendi a necessidade de implementar essas funções para me retornar um alert caso queira inserir um valor maior do que descrito no vetor e se caso tentar desempilhar uma pilha vazia para ambos não retornarem erro como tem acontecido.

Sim... mas o papel principal desses funções é proteger o acesso ao vetor... para não deixar o programa tentar acessar uma posição que não existe! Exibir uma mensagem na tela seria apenas uma complementação. O cerne é não deixar o programa dar pau! (Vazio() é para não deixar remover de uma posição que não existe, ou seja: antes do 0. E Cheia() seria para não deixar inserir numa posição após a última, ou seja: depois do 9.

Sobre:

14 horas atrás, pablopccosta disse:

Não sei se estou verificando da forma certa, está faltando algo. Usei a função se, tanto para "empilhar" (se cheia) e para o "desempilhar" (se vazia) [...]

A ideia estaria certa, só que em vez de criar uma expressão para os se, o mais correto seria utilizar a função que já existe... a final, as funções correspondentes foram feitas justamente para serem utilizadas para esse fim!!!

Segue um exemplo de como poderia usar:

//Lista todos os elementos armazenados na pilha
procedimento Listar(topo: inteiro)
var
   i: inteiro
inicio
   se Vazia(topo) entao
      escreval("Pilha vazia!")
   senao
      para i de topo ate 0 passo -1 faca
         escreval(pilha[i])
      fimPara
   fimSe
fimProcedimento

Percebe? A forma de como verifica se está vazio fica "abstraído" para dentro da função. Observe que a informação de onde é o "início" (o topo) da pilha está vindo pelo parâmetro... lá na minha postagem anterior eu esqueci de fazer isso. Foi mal!, lá no outro código estou acessando o valor pela variável global... o que não é desejável, pelo menos no sentido do que foi proposto.

Veja:

Em 29/03/2021 às 12:12, Simon Viegas disse:

De um modo simplificado, a orientação/sugestão é que tudo que uma função ou procedimento vai precisar, OU ela vai receber por parâmetro, OU ela tem dentro dela mesma...

Daí, como essa função passou a ter um parâmetro, na hora de invocar ela é preciso passar o valor que a função exige, no caso "um inteiro", que no contexto é o valor do índice, que por sua vez está em topo.

ADENDO:
Não precisa ter o mesmo nome!!! Poderia ser assim:

//Lista todos os elementos armazenados na pilha
procedimento Listar(t: inteiro)
var
   i: inteiro
inicio
   se Vazia(t) entao
      escreval("Pilha vazia!")
   senao
      para i de topo ate 0 passo -1 faca
         escreval(pilha[i])
      fimPara
   fimSe
fimProcedimento

Daí, na hora de chamar o Listar() lá no menu, continuaria do mesmo jeito.

      caso 4
         limpaTela()
         Listar(topo)

As funções e procedimentos devem ser invocados de acordo com as suas assinaturas... se lá está recebendo um inteiro, entrem precisa passar um inteiro... no contexto, o inteiro que precisa está na variável topo.

Deu para entender? Para listar, é precisa de 2 coisas: o vetor e a posição que representa o topo da pilha. Tanto o vetor, tanto essa posição precisaria ser passado por parâmetro, já que, como "sugerido", não queremos usar variáveis globais dentro de uma função, ou seja: "ou o valor vem por parâmetro, ou a variável é criada dentro da função". O problema é que VisualG não aceita vetores por parâmetros, daí, os vetores ficam como uma exceção, mas o índice "deveria" passar mesmo.

Sobre:

14 horas atrás, pablopccosta disse:

[...], mas, quando a pilha fica cheia, me retorna a mensagem de "pilha cheia", em seguida coloco para listar e me retorna "erro".

Que erro?

Eu até já descobri aqui... veja qual erro está dando... dica: a posição 10 não existe para o seu vetor. O que está errado lá no meu código de listar?

Sobre:

15 horas atrás, pablopccosta disse:

Se "pilha vazia", me retorna a mensagem de "pilha vazia" e em baixo a primeira letra inserida na pilha. (Isso ta me deixando maluco já). Eu encerro o programa e inicio novamente, se eu testar o "listar" para testar e em seguida o desempilhar, aparece a última letra inserida na pilha da execução anterior do programa, mesmo depois de eu ter encerrado e iniciado novamente. Imagino que seja algum erro. (print em anexo).

A função "vazia" mudei conforme você orientou para simplificar mas está dando erro também. (print em anexo)

tenho impressão de que quando desempilho uma letra, o espaço da variável fica lá ainda, como se a linha estivesse ali ainda. Acredito que a ideia seja: Após desempilhar uma letra, a última ainda na pilha deve ocupar o topo, ou seja, a posição 0 do vetor.

O restante que orientou consegui implementar.

Mudei as "variáveis globais" para o final do código;

Criei uma "variável local" para a var letra, removendo-a do parâmetro do procedimento;

Se puder continuar tirando essas minhas dúvidas te agradeço.

De um modo geral, seria meio que bug do VisualG... que por sua vez seria "estimulado" por um erro de sintaxe no código. Basicamente seria isso:

Vamos tomar por exemplo o código abaixo:

//Retorna VERDADEIRO se a pilha estiver vazia ou FALSO caso contrário
funcao Vazia(topo: inteiro): logico
inicio
   se topo = 0 entao
      retorne VERDADEIRO
   senao
      retorne FALSO
   fimSe
fimFuncao

Como Vazia() precisa de uma parâmetro, necessariamente é preciso invocar utilizando um parâmetro. Exemplo:

procedimento Listar(t: inteiro)
var
   i: inteiro
inicio
   se Vazia(t) entao //<-- aqui está invocando Vazia() passando um inteiro
      escreval("Pilha vazia!")

Dá mesma forma que o Listar() deve ser invocado com um tipo de valor correto... no caso, Listar(topo).

Agora, se tentar chamar a função assim:

procedimento Listar(t: inteiro)
var
   i: inteiro
inicio
   se Vazia() entao //Aqui uma bomba preste a explodir!!! 
      escreval("Pilha vazia!")

Num "compilador" mais avançado, o código nem ia ser compilado!!! Mas aqui no VisualG o bagulho roda e acaba dando uns erros sinistros, rs. Mas o que precisamos focar aqui é na essência... toda vez que você for utilizar uma função, ela deve ser invocada passando necessariamente os parâmetros que ela exige. É isso. No seu código, o Vazia() já está exigindo um parâmetro, logo lá no seu menu deve invocar com o parâmetro correto, algo como Vazia(topo).

pablopccosta · 5 de abril de 2021

Em 03/04/2021 às 17:45, Simon Viegas disse:

Deu para entender? Para listar, é precisa de 2 coisas: o vetor e a posição que representa o topo da pilha. Tanto o vetor, tanto essa posição precisaria ser passado por parâmetro, já que, como "sugerido", não queremos usar variáveis globais dentro de uma função, ou seja: "ou o valor vem por parâmetro, ou a variável é criada dentro da função". O problema é que VisualG não aceita vetores por parâmetros, daí, os vetores ficam como uma exceção, mas o índice "deveria" passar mesmo.

Perfeito amigo, compreendi. Usar uma função que já faz parte do algorítimo da coesão ao mesmo, além de ser uma boa prática e garantir que funcione corretamente. Mas está dando erro rs. O erro diz que esperava uma "," (vírgula) quando coloco dentro do parâmetro a variável. No menu o erro diz: Variável não encontrada. Cara, sinceramente acho que depois das suas explicações entendo que o visualg é limitado à algumas coisas. Acredito que ele seja usado pela sua didática, facilidade de compreensão. Mas esses erros sem causa justa atrapalha o entendimento.

Simon Viegas · 5 de abril de 2021

@pablopccosta, fala aí os ajustes e poste o código completo para poder ser analisado e também, eventualmente, poder servi de base para outros visitantes.

pablopccosta · 9 de abril de 2021

Em 05/04/2021 às 09:48, Simon Viegas disse:

fala aí os ajustes e poste o código completo para poder ser analisado e também, eventualmente, poder servi de base para outros visitantes.

Boa noite a todos!

Desculpe a demora para responder Simon.

Fiz acredito que todos os ajustes que você me orientou, está dando alguns erros ainda.

Na variável global, só deixei o vetor e outra variável que seria usada no menu, de resto declarei nas locais mesmo. Esse código para mim está uma incógnita

Algoritmo "Implementação de Pilha-PABLO"
// Descrição   : SA4 - Atividade 1 Implementação de Pilha
// Autor(a)    : Pablo
// Data atual  : 15/3/2021

//Empilhar (adiciona um elemento no topo da pilha);
procedimento empilhar()
var
   letra: caractere
   topo: inteiro

inicio
   escreval(" Digite a letra que deseja empilhar:")
   leia(letra)
   se topo = 10 entao
      escreval(" Pilha cheia!")
   senao
      pilha[topo]:= letra
      topo:= topo + 1
   fimse

fimprocedimento

//Desempilhar (remove e retorna um elemento do topo da pilha);
funcao desempilhar(): caractere
var
   elemento: caractere
   topo: inteiro

inicio
   se topo = 0 entao
      escreva(" Não há valor para desempilhar!")
   senao
      elemento:= pilha[topo-1]
      pilha[topo-1]:= ""
      topo:= topo-1
      retorne elemento
   fimse

fimfuncao

//Limpar (remove todos os elementos da pilha);
procedimento limpar()
var
   contNum: inteiro

inicio
   para contNum de 0 ate 9 faca
      pilha[contNum]:= ""
   fimpara

fimprocedimento

//Listar (lista todos os elementos armazenados na pilha);
procedimento listar(topo: inteiro)
var
   i: inteiro

inicio
   se vazia (topo) entao
      escreval("Pilha vazia!")
   senao
      para i de topo ate 0 passo -1 faca
         escreval(pilha[i])
      fimPara
   fimSe
fimProcedimento

//Retorna VERDADEIRO se a pilha estiver vazia ou FALSO caso contrário
funcao vazia(topo: inteiro): logico
var
   topo: inteiro

inicio
   se topo = 0 entao
      retorne VERDADEIRO
   senao
      retorne FALSO
   fimSe
fimFuncao

var
   pilha:vetor[0..9] de caractere
   op: inteiro

inicio
   // Seção de Comandos, procedimento, funções, operadores, etc...
   enquanto op <> 6 faca
      escreval("")
      escreval("-----------IMPLEMENTAÇÃO DE PILHA------------")
      escreval("")
      escreval("°1 Empilhar")
      escreval("°2 Desempilhar")
      escreval("°3 Limpar")
      escreval("°4 Listar")
      escreval("°5 Vazia")
      escreval("")
      escreval(" Digite a opção desejada:")
      leia(op)

      escolha op

      caso 1
         limpatela
         empilhar()

      caso 2
         limpatela
         escreval(desempilhar())

      caso 3
         limpatela
         limpar()

      caso 4
         limpatela
         listar(topo)

      caso 5
         limpatela
         escreval (vazia(topo))

      fimescolha
   fimenquanto

Fimalgoritmo

Simon Viegas · 12 de abril de 2021

Em 09/04/2021 às 20:57, pablopccosta disse:

Fiz acredito que todos os ajustes que você me orientou, está dando alguns erros ainda.

Quais erros está ocorrendo?

Simon Viegas · 12 de abril de 2021

Adiantando algumas coisas:

1# Faltou declarar a variável topo

var
   pilha: vetor[0..9] de caractere
   topo: inteiro
   op: inteiro

2# Faltou implementar função Cheia()

//Retorna VERDADEIRO se a pilha estiver cheia ou FALSO caso contrário
funcao Cheia(topo: inteiro): logico
inicio
   se topo = 10 entao
      retorne VERDADEIRO
   senao
      retorne FALSO
   fimSe
fimFuncao

3# Utilizar passagem por referência quando a variável pode ser alterada nos métodos (função ou procedimento)

Para empilhar, precisa do [1] vetor, da [2] posição do topo e do [3] elemento a ser inserido, correto?

O vetor é acessado diretamente pelo escopo global (pois o VisualG não aceita vetores por parâmetro); O elemento a ser inserido você decidiu que seria lido dentro da função, e assim está sendo feito (acho que isso precisa ser repensado); Já a posição do topo vem de fora... daí sendo recebido por parâmetro... só que, por padrão, as variáveis são passadas por valor, ou seja: essa variável que está na assinatura vai receber uma "cópia do valor que foi passado ao chamar esse procedimento". Daí, é necessário configurar para passar por referência, ou seja: ao alterar a variável do parâmetro, vai alterar diretamente a própria variável que foi utilizada ao chamar o procedimento.

Basta colocar um var antes do parâmetro, veja:

//Adiciona um elemento no topo da pilha
procedimento Empilhar(var topo: inteiro)
var
   letra: caractere
inicio
   se Cheia(topo) entao
      escreval(" Pilha cheia!")
   senao
      escreva (" Digite a letra que deseja empilhar: ")
      leia(letra)
      pilha[topo] <- letra
      topo <- topo + 1
   fimSe
fimProcedimento

//Remove e retorna um elemento do topo da pilha
funcao Desempilhar(var topo: inteiro): caractere
var
   elemento: caractere
inicio
   se Vazia(topo) entao
      escreva(" Não há valor para desempilhar!")
   senao
      elemento <- pilha[topo-1]
      topo <- topo-1
      retorne elemento
   fimSe
fimFuncao

Perceba que para as outra funções não precisa desse var, já que basta o "valor" da variável.

Veja: a variável topo declarada aí nas funções NÃO é a mesma da variável topo global. São variáveis distintas... ela apenas tem o mesmo nome... (mais acima eu já comentei que pode utilizar outro nome sem problema). Ficar com o mesmo nome foi a pena por conveniência.

Se não colocar esse var, as alterações na variável topo (dentro da função) são serão persistidas na variável topo (global). Simplesmente não vai conseguir cadastrar.

#4 Por fim só corrigir as chamadas dos métodos

inicio
   enquanto op <> 6 faca
      escreval("")
      escreval("-----------IMPLEMENTAÇÃO DE PILHA------------")
      escreval("")
      escreval("°1 Empilhar")
      escreval("°2 Desempilhar")
      escreval("°3 Limpar")
      escreval("°4 Listar")
      escreval("°5 Vazia")
      escreval("")
      escreval(" Digite a opção desejada:")
      leia(op)
      
      limpaTela()

      escolha op
      caso 1
         Empilhar(topo)
      caso 2
         escreval(Desempilhar(topo))
      caso 3
         Limpar(topo)
      caso 4
         Listar(topo)
      caso 5
         escreval(Vazia(topo))
      fimEscolha
   fimEnquanto
fimAlgoritmo

***

Com isso meio que corrige os principais pontos.

Faça os ajustes e poste o código completo, assim como o enunciado da questão.

Adiantando algumas coisas:

1# Faltou declarar a variável topo

var
   pilha: vetor[0..9] de caractere
   topo: inteiro
   op: inteiro

2# Faltou implementar função Cheia()

//Retorna VERDADEIRO se a pilha estiver cheia ou FALSO caso contrário
funcao Cheia(topo: inteiro): logico
inicio
   se topo = 10 entao
      retorne VERDADEIRO
   senao
      retorne FALSO
   fimSe
fimFuncao

3# Utilizar passagem por referência quando a variável pode ser alterada nos métodos (função ou procedimento)

Para empilhar, precisa do [1] vetor, da [2] posição do topo e do [3] elemento a ser inserido, correto?

O vetor é acessado diretamente pelo escopo global (pois o VisualG não aceita vetores por parâmetro); O elemento a ser inserido você decidiu que seria lido dentro da função, e assim está sendo feito (acho que isso precisa ser repensado); Já a posição do topo vem de fora... daí sendo recebido por parâmetro... só que, por padrão, as variáveis são passadas por valor, ou seja: essa variável que está na assinatura vai receber uma "cópia do valor que foi passado ao chamar esse procedimento". Daí, é necessário configurar para passar por referência, ou seja: ao alterar a variável do parâmetro, vai alterar diretamente a própria variável que foi utilizada ao chamar o procedimento.

Basta colocar um var antes do parâmetro, veja:

//Adiciona um elemento no topo da pilha
procedimento Empilhar(var topo: inteiro)
var
   letra: caractere
inicio
   se Cheia(topo) entao
      escreval(" Pilha cheia!")
   senao
      escreva (" Digite a letra que deseja empilhar: ")
      leia(letra)
      pilha[topo] <- letra
      topo <- topo + 1
   fimSe
fimProcedimento

//Remove e retorna um elemento do topo da pilha
funcao Desempilhar(var topo: inteiro): caractere
var
   elemento: caractere
inicio
   se Vazia(topo) entao
      escreva(" Não há valor para desempilhar!")
   senao
      elemento <- pilha[topo-1]
      topo <- topo-1
      retorne elemento
   fimSe
fimFuncao

Perceba que para as outra funções não precisa desse var, já que basta o "valor" da variável.

Veja: a variável topo declarada aí nas funções NÃO é a mesma da variável topo global. São variáveis distintas... ela apenas tem o mesmo nome... (mais acima eu já comentei que pode utilizar outro nome sem problema). Ficar com o mesmo nome foi a pena por conveniência.

Se não colocar esse var, as alterações na variável topo (dentro da função) são serão persistidas na variável topo (global). Simplesmente não vai conseguir cadastrar.

#4 Por fim só corrigir as chamadas dos métodos

inicio
   enquanto op <> 6 faca
      escreval("")
      escreval("-----------IMPLEMENTAÇÃO DE PILHA------------")
      escreval("")
      escreval("°1 Empilhar")
      escreval("°2 Desempilhar")
      escreval("°3 Limpar")
      escreval("°4 Listar")
      escreval("°5 Vazia")
      escreval("")
      escreval(" Digite a opção desejada:")
      leia(op)
      
      limpaTela()

      escolha op
      caso 1
         Empilhar(topo)
      caso 2
         escreval(Desempilhar(topo))
      caso 3
         Limpar(topo)
      caso 4
         Listar(topo)
      caso 5
         escreval(Vazia(topo))
      fimEscolha
   fimEnquanto
fimAlgoritmo