VisualG Cadastro de produtos, consulta de estoques usando vetores

Eli Almeida · 17 de setembro de 2023

Enunciado da questão:

Você foi designado para criar um programa em portugol que ajude uma loja a gerenciar seu estoque de produtos eletrônicos. A loja possui um catálogo de produtos, cada um representado por um vetor de registro com as seguintes informações:

Nome do produto (string)
Preço unitário (real)
Quantidade em estoque (inteiro)

Sua tarefa é escrever um programa que realize as seguintes operações através de funções:

Cadastro de Produto: Crie uma função que permita ao usuário cadastrar um novo produto, informando o nome, preço unitário e quantidade em estoque. Os dados devem ser armazenados no vetor de produtos.
Consulta de Estoque: Crie uma função que permita ao usuário consultar o estoque de um produto específico, informando o nome do produto. A função deve retornar a quantidade em estoque desse produto.
Atualização de Estoque: Crie uma função que permita ao usuário atualizar o estoque de um produto existente, informando o nome do produto e a quantidade a ser adicionada ou subtraída do estoque.
Listagem de Produtos: Crie uma função que liste todos os produtos cadastrados, exibindo o nome, preço unitário e quantidade em estoque de cada um.

Fiz esse código para a questão, mas não sei se está correto e se o que as funções retornam está legal, se alguém puder

executar e me ver o que precisa mudar, melhorar :

Algoritmo "ProdutosEletronicos"

Var
   nomesProdutos : vetor [1..2] de caractere
   precosProdutos : vetor [1..2] de real
   estoqueProdutos : vetor [1..2] de inteiro
   produtosNaoCadastrados : logico
   opcao, resultado, produtosCadastrados : inteiro

funcao cadastrarProduto (): inteiro
var
   contador, lugaresOcupados : inteiro
   resposta, s : caractere

inicio

   resposta <- "s"
   contador <-1
   enquanto (resposta = "s") e (contador <= 2) faca
      se (nomesProdutos[contador] = "") e (precosProdutos[contador] = 0) e (estoqueProdutos[contador] = 0) então
         escreval("Informe o nome do produto")
         leia(nomesProdutos[contador])
         escreval ("Informe o preço do produto")
         leia(precosProdutos[contador])
         escreval ("Informe a quantidade em estoque")
         leia(estoqueProdutos[contador])
         escreval ("Produto Cadastrado com sucesso")
         produtosCadastrados <- produtosCadastrados + 1
         produtosNaoCadastrados <- falso
         escreval (" Quer cadastrar outro produto? S/N")
         leia(resposta)
         se resposta = "s" então
            contador <- contador + 1
         senao
            escreval ("Cadastro de produtos concluído.")
         fimSe
      senao
         lugaresOcupados <- lugaresOcupados+1
         se lugaresOcupados = 2 então
            escreval("Não há mais espaços disponíveis")
         fimSe
         contador <- contador + 1

      fimse
   fimEnquanto

   retorne produtosCadastrados
fimFuncao


funcao consultarEstoque(): inteiro
var
   contador  : inteiro
   nome ,x: caractere
inicio
   escreval("Informe o nome do produto que gostaria de consultar")
   leia(nome)
   para contador <- 1 ate 2 faca
      se nome = nomesProdutos[contador] então
         retorne (estoqueProdutos[contador])
      fimse
   fimPara
fimFuncao

funcao atualizarEstoque(): inteiro
var
   contador, quantidade : inteiro
   resposta, nome : caractere
inicio
   escreval("Informe o nome do produto que gostaria de adicionar ou retirar")
   leia(nome)
   para contador <- 1 ate 2 faca
      se nome = nomesProdutos[contador] então
         escreval (" Gostaria de retirar ou adiconar? A/R")
         leia(resposta)
         escreval (" Quanto?")
         leia(quantidade)

         se opcao = "a" então
            estoqueProdutos[contador]<- estoqueProdutos[contador]+quantidade
            escreval(" A quantidade adicionada é :", quantidade)
            escreval (" O novo estoque é :")
            retorne estoqueProdutos[contador]
            interrompa

         senao
            se opcao = "r" então
               se (estoqueProdutos [contador] > quantidade) então
                  estoqueProdutos [contador] <- estoqueProdutos[contador]-quantidade
                  escreval(" A quantidade retirada é :", quantidade)
                  escreva (" O novo estoque é:")
                  retorne estoqueProdutos[contador]
               senao
                  se (estoqueProdutos [contador] = quantidade) então
                     estoqueProdutos[contador]<- estoqueProdutos[contador]-quantidade
                     nomesProdutos[contador]<- ""
                     precosProdutos[contador]<- 0
                     escreval (" O produto foi removido, pois não tem mais estoque")
                     produtosCadastrados<- produtosCadastrados-1
                     retorne  estoqueProdutos[contador]
                     escreval ("Tentativa inválida!")
                     escreva("produtos retirados :")
                     retorne 0
                  fimSe
               fimse
            fimse
         fimse
      fimse
   fimPara
fimFuncao
funcao listarProduto(): inteiro
var
   contador, produtosCadastrados : inteiro
inicio
   escreval (" Produtos cadastrados :")
   para contador <- 1 ate 2 faca
      se (nomesProdutos[contador]<> "") e (precosProdutos[contador]<> 0) e (estoqueProdutos[contador]<> 0) então
         escreval ("Nome :", nomesProdutos[contador])
         escreval( "Preço :", precosProdutos[contador])
         escreval ("Estoque :", estoqueProdutos[contador] )
         produtosCadastrados <- produtosCadastrados+1
         escreval()

      fimSe
   fimPara
   escreva ("Produtos listados :")
   retorne produtosCadastrados
fimfuncao


Inicio

   produtosNaoCadastrados <- verdadeiro
   repita
      escreval()
      escreval(" Loja de produtos eletrônicos")
      escreval(" Escolha uma opção:")
      escreval (" 1 - Cadastrar produtos ")
      escreval (" 2 - consultarEstoque ")
      escreval (" 3 - Atualizar estoque ")
      escreval (" 4 - Listar Produtos ")
      escreval (" 0 -  Sair ")
      leia(opcao)
      limpaTela
      escolha opcao
      caso 1
         resultado <- cadastrarProduto()
         escreval("Produtos Cadastrados :", resultado)
      caso  2
         se produtosNaoCadastrados então
            escreval(" Produtos cadastrados :", produtosCadastrados)
            escreval(" Cadastre um produto primeiro")
         senao
            resultado <- consultarEstoque()
            escreval("estoque do produto :", resultado)
         fimSe
      caso 3
         se produtosNaoCadastrados então
            escreva(" Produtos cadastrados :", produtosCadastrados)
         senao
            resultado <- atualizarEstoque()
            escreval(resultado)
         fimse
      caso 4
         se produtosNaoCadastrados então
            escreva(" Produtos cadastrados :",  produtosCadastrados)
         senao
            escreval(listarProduto)
         fimSe

      fimEscolha
   ate (opcao = 0)
Fimalgoritmo

kgin · 18 de setembro de 2023

5 horas atrás, Eli Almeidaa disse:

Fiz esse código para a questão, mas não sei se está correto e se o que as funções retornam está legal, se alguém puder

executar e me ver o que precisa mudar, melhorar :

Eu acho que você deveria usar registros, veja nesse trecho do enunciado

5 horas atrás, Eli Almeidaa disse:

A loja possui um catálogo de produtos, cada um representado por um vetor de registro com as seguintes informações:

então nessa parte do seu código

Var
   nomesProdutos : vetor [1..2] de caractere
   precosProdutos : vetor [1..2] de real
   estoqueProdutos : vetor [1..2] de inteiro
   produtosNaoCadastrados : logico

Deveria ser algo assim

const
   QUANTIDADE_MAXIMA_PRODUTOS = 100

tipo
   t_produto = registro
      nome:caractere
      preco:real
      estoque:inteiro
   fimRegistro
   
   integer = inteiro

var
   produtos: vetor [1..QUANTIDADE_MAXIMA_PRODUTOS] de t_produto
   quantidade_produtos_cadastrados:inteiro

isso é um recurso pouco documentado do visualG, então eu sugiro você ler esse livro de pascal para entender melhor o funcionamento (pagina 105 - Registros).

Eli Almeida · 19 de setembro de 2023

@kgin , valeu, estou pesquisando sobre registro, não sabia que existia em portugol.

Não sei por que esse código aqui, não está funcionando, será que você conseguiria encontrar o erro?

Algoritmo "Gerenciamento de Produtos"
//
const
   QUANTIDADE_MAXIMA_PRODUTOS = 100

tipo
   t_produto = registro
      nome: caractere
      preco: real
      estoque: inteiro
   fimRegistro

var
   produtos: vetor [1..QUANTIDADE_MAXIMA_PRODUTOS] de t_produto
   quantidade_produtos_cadastrados: inteiro

Inicio

   produtos[1].nome <- "Produto A"
   produtos[1].preco <- 9.99
   produtos[1].estoque <- 50

   escreva("Nome do produto: ", produtos[1].nome)


   escreva("Preço do produto: ", produtos[1].preco)


   escreva("Estoque do produto: ", produtos[1].estoque)


Fimalgoritmo

Midori · 19 de setembro de 2023

18 horas atrás, Eli Almeidaa disse:

Não sei por que esse código aqui, não está funcionando, será que você conseguiria encontrar o erro?

Que erro acontece? Aqui funcionou corretamente.

Eli Almeida · 19 de setembro de 2023

@Midori , às vezes funciona, mas às vezes não e aparece esse erro :

Midori · 20 de setembro de 2023

@Eli Almeidaa Isso acontece ao executar o passo a passo (F8) e em seguida F9. Se rodar sempre com F9 isso não acontece.

Eli Almeida · 22 de setembro de 2023

Tô tentando fazer assim agora,

troquei a função cadastrarProduto pelo procedimento cadastrarProduto, porque não sei o que a função

poderia retornar e o procedimento não retorna nada. Será que esse início estaria adequado agora?

Algoritmo "Gerenciamento de Produtos"

const
   quantidadeMaximaProdutos = 2

tipo
   loja = registro
      nome: caractere
      preco: real
      estoque: inteiro
   fimRegistro

var
   produtos: vetor [1..quantidadeMaximaProdutos] de loja
   quantidadeProdutosCadastrados, opcao: inteiro

procedimento cadastrarProduto()
inicio
   escreval("Informe o nome do produto")
   leia(produtos[quantidadeProdutosCadastrados].nome)
   escreval("Informe o preço do produto")
   leia(produtos[quantidadeProdutosCadastrados].preco)
   escreval("Informe o estoque do produto")
   leia(produtos[quantidadeProdutosCadastrados].estoque)
   quantidadeProdutosCadastrados <- quantidadeProdutosCadastrados+1
   escreval("Produto cadastrado com sucesso")
fimProcedimento

Inicio

   quantidadeProdutoscadastrados <- 1

   se quantidadeProdutosCadastrados <= quantidadeMaximaProdutos então
      cadastrarProduto()
   senao
      escreval(" Limite de cadastro atingido")
   fimSe

Fimalgoritmo

kgin · 23 de setembro de 2023

23 horas atrás, Eli Almeidaa disse:

Tô tentando fazer assim agora,

troquei a função cadastrarProduto pelo procedimento cadastrarProduto, porque não sei o que a função

poderia retornar e o procedimento não retorna nada. Será que esse início estaria adequado agora?

Esta sim!

Veja que no enunciado não pede para retornar nada

Em 17/09/2023 às 17:13, Eli Almeidaa disse:

Cadastro de Produto: Crie uma função que permita ao usuário cadastrar um novo produto, informando o nome, preço unitário e quantidade em estoque. Os dados devem ser armazenados no vetor de produtos.

Uma melhoria seria colocar algumas checagens de entrada para evitar informações duplicadas.

Dessa maneira

funcao produto_existe(nome:caractere):inteiro
var
   contador:inteiro
inicio
   retorne 0
   para contador de 1 ate quantidade_produtos_cadastrados faca
      se nome = produtos[contador].nome então
         retorne contador
         interrompa
      fimSe
   fimPara
fimFuncao

procedimento cadastra_produto
var
   opcao:caractere
inicio
   repita
      escreva("Digite o nome do produto:")
      leia(p_temp.nome)
      se (produto_existe(p_temp.nome) > 0) então
         escreval("O produto ", p_temp.nome, " Já existe no cadastro!")
         escreval("Deseja continuar cadastrando outro?")
         escreva("[S/N]:")
         leia(opcao)
         se (opcao <> "s") então
            interrompa
         fimSe
      fimSE
   ate não ((produto_existe(p_temp.nome) > 0) e (opcao = "s"))
fimProcedimento

Fiz de cabeça e provavelmente nem funciona :b

Eli Almeida · 16 de outubro de 2023

Estou fazendo assim agora, porém está dando erro, quando cadastra dois produtos e tenta consultar o estoque do primeiro produto

cadastrado, não funciona e aparece a mensagem "Produto não cadastrado", que não era para aparecer. Se alguém puder identificar o erro aqui :

Algoritmo "Gerenciamento de Produtos"

const
   quantidadeMaximaProdutos = 2

tipo
   loja = registro
      nome: caractere
      preco: real
      estoque: inteiro
   fimRegistro

var
   produtos: vetor [1..quantidadeMaximaProdutos] de loja
   quantidadeProdutosCadastrados, opcao, r : inteiro
   nome  : caractere


funcao produtoExiste(nome:caractere):inteiro
var
   contador:inteiro
inicio
   para contador <- 1 ate quantidadeProdutosCadastrados faca
      se nome = produtos[contador].nome então
         retorne contador
         interrompa()
      fimse
   fimPara
   retorne 0
fimFuncao

procedimento cadastrarProduto()
inicio
   escreval("Informe o nome do produto")
   leia(nome)
   se (produtoExiste(nome) > 0) então
      escreval("O produto ", produtos[quantidadeProdutosCadastrados].nome, " Já existe no cadastro!")
   senao
      produtos[quantidadeProdutosCadastrados].nome <- nome
      escreval("Informe o preço do produto")
      leia(produtos[quantidadeProdutosCadastrados].preco)
      escreval("Informe o estoque do produto")
      leia(produtos[quantidadeProdutosCadastrados].estoque)
      quantidadeProdutosCadastrados <- quantidadeProdutosCadastrados+1
      escreval("Produto cadastrado com sucesso")
   fimSe
fimProcedimento

funcao consultarEstoque(nome:caractere) : inteiro
var
   contador : inteiro
inicio
   para  contador <- 1 ate quantidadeProdutosCadastrados faca
      se nome = produtos[contador].nome então
         retorne produtos[contador].estoque
      fimSe
   fimPara
fimFuncao

Inicio

   quantidadeProdutoscadastrados <- 1
   repita

      escreval("[1]Cadastrar produto")
      escreval("[2] Consultar estoque")
      escreval("Escolha uma opcao")
      leia (opcao)
      escolha opcao
      caso 1
         se quantidadeProdutosCadastrados <= quantidadeMaximaProdutos então
            cadastrarProduto()
         senao
            escreval(" Limite de cadastro atingido")
         fimSe
      caso 2
         escreval ("Informe o nome do produto que deseja consultar o estoque")
         leia(nome)
         r <- produtoExiste(nome)
         se  produtoExiste(nome) > 0 então
            r <- consultarEstoque(nome)
            escreval(" A quantidade de estoque do produto ", nome, " é ", r:1)
         senao
            escreval(" Produto não cadastrado.")
         fimSe
      fimescolha
   ate (opcao=0)
Fimalgoritmo

devair1010 · 16 de outubro de 2023

@Eli Almeidaa essa Função "produtoExiste" contém um erro , pois no visualG o comando retorne funciona de outra forma , pois ele não retorna imediatamente , não , e só retorna mesmo no final da função , assim você precisa fazer o controle do valor que será retornado, usando uma variável auxiliar , e lá no final da Função, no comando retorne, coloque esse valor que será retornado aí sim nesse momento ,

funcao produtoExiste(nome:caractere):inteiro
var
   contador, flg:inteiro
inicio

   para contador <- 1 ate quantidadeProdutosCadastrados faca
      se nome = produtos[contador].nome então
         // retorne contador não iRah retornar nada aqui
         flg := contador     /// armazena o valor que será retornado
         interrompa("32768") /// interrompe o loop para / fimpara
      fimse
   fimPara
   retorne flg               /// aqui sim , vai retornaR o valor deseJado .
fimFuncao

Eli Almeida · 17 de outubro de 2023

@devair1010, valeu funcionou agora. Troquei "flg" por "resultado".

Acrescentei outra função que é " Atualizar estoque". Será que dessa forma que eu fiz estaria certo? Ouvir dizer que se deve evitar colocar texto dentro da função, que ela deve ser usada mais para retornar o resultado.

Algoritmo "Gerenciamento de Produtos"

const
   quantidadeMaximaProdutos = 2

tipo
   loja = registro
      nome: caractere
      preco: real
      estoque: inteiro
   fimRegistro

var
   produtos: vetor [1..quantidadeMaximaProdutos] de loja
   quantidadeProdutosCadastrados, opcao, r, quantidade : inteiro
   nome, opcao2  : caractere


funcao produtoExiste(nome:caractere):inteiro
var
   contador, resultado:inteiro
inicio

   para contador <- 1 ate quantidadeProdutosCadastrados faca
      se nome = produtos[contador].nome então
         resultado <- contador
         interrompa()
      fimse
   fimPara
   retorne resultado
fimFuncao


procedimento cadastrarProduto()
inicio
   escreval("Informe o nome do produto")
   leia(nome)
   se (produtoExiste(nome) > 0) então
      escreval("O produto ", produtos[quantidadeProdutosCadastrados].nome, " Já existe no cadastro!")
   senao
      produtos[quantidadeProdutosCadastrados].nome <- nome
      escreval("Informe o preço do produto")
      leia(produtos[quantidadeProdutosCadastrados].preco)
      escreval("Informe o estoque do produto")
      leia(produtos[quantidadeProdutosCadastrados].estoque)
      quantidadeProdutosCadastrados <- quantidadeProdutosCadastrados+1
      escreval("Produto cadastrado com sucesso")
   fimSe
fimProcedimento


funcao consultarEstoque(nome:caractere) : inteiro
var
   contador : inteiro
   resultado:inteiro
inicio
   para  contador <- 1 ate quantidadeProdutosCadastrados faca
      se nome = produtos[contador].nome então
         resultado <- produtos[contador].estoque
         interrompa()
      fimSe
   fimPara
   retorne resultado
fimFuncao

funcao atualizarEstoque (opcao2:caractere;quantidade:inteiro) : inteiro
var
   contador, c : inteiro
inicio
   para contador <- 1 ate quantidadeProdutosCadastrados faca
      se opcao2 = "R" então
         produtos[contador].estoque <-  produtos[contador].estoque - quantidade
         c <- produtos[contador].estoque
         interrompa
      senao
         se opcao2 = "A" então
            produtos[contador].estoque <-  produtos[contador].estoque + quantidade
            c <- produtos[contador].estoque
            interrompa
         fimSe
      fimse
   fimPara
   retorne c
fimfuncao

Inicio

   quantidadeProdutoscadastrados <- 1
   repita

      escreval("[1]- Cadastrar produto")
      escreval("[2]- consultar produto")
      escreval("[3]- atualizar estoque")
      escreval ("[4]- listar produtos")
      
      escreval("Escolha uma opcao")
      leia (opcao)
      escolha opcao
      caso 1
         se quantidadeProdutosCadastrados <= quantidadeMaximaProdutos então
            cadastrarProduto()
         senao
            escreval(" Limite de cadastro atingido")
         fimSe
      caso 2
         escreval ("Informe o nome do produto que deseja consultar o estoque")
         leia(nome)
         r <- produtoExiste(nome)
         se r > 0 então
            r <- consultarEstoque(nome)
            escreval(" A quantidade de estoque do produto ", nome, " é ", r:1)
         senao
            escreval(" Produto não cadastrado.")
         fimSe
      caso 3
         escreval ("Informe o nome do produto que deseja atualizar o estoque")
         leia(nome)
         r <- produtoExiste(nome)
         se r > 0 então
            escreval ("[R] - retirar")
            escreval("[A] - adicionar")
            leia(opcao2)
            opcao2 <- maiusc(opcao2)
            se opcao2 = "R" então
               escreval ("Quanto gostaria de retirar")
               leia(quantidade)
               r <- atualizarEstoque(opcao2,quantidade)
               escreval("O novo estoque é de ", nome, " é ", r:1)
            senao
               se opcao2 = "A" então
                  escreval ("Quanto gostaria de adicionar")
                  leia(quantidade)
                  r <- atualizarEstoque(opcao2,quantidade)
                  escreval("O novo estoque é de ", nome, " é ", r:1)
               fimse
            fimse
         senao
            escreval(" Produto não cadastrado.")
         fimSe
         
      fimescolha
   ate (opcao=0)

Fimalgoritmo

devair1010 · 18 de outubro de 2023

@Eli Almeidaa está certo , sim , porém faltou um código para a opção 4 do menu , que sugere mostrar Todos os produtos cadastrados , imagino algo assim :

Algoritmo "Gerenciamento de Produtos_2"
const
   quantidadeMaximaProdutos = 2

tipo
   loja       = registro
      nome    : caractere
      preco   : real
      estoque : inteiro
   fimRegistro

var
   produtos                      : vetor [1..quantidadeMaximaProdutos] de loja
   quantidadeProdutosCadastrados : inteiro
   opcao, r, quantidade,a        : inteiro
   nome, opcao2                  : caractere

funcao produtoExiste( nome : caractere ) : inteiro
var
   contador, resultado : inteiro
inicio
   para contador   <- 1 ate quantidadeProdutosCadastrados faca
      se nome      =  produtos[contador].nome então
         resultado <- contador
         interrompa()
      fimse
   fimPara
   retorne resultado
fimFuncao

procedimento cadastrarProduto()
inicio
   escreval("Informe o nome do produto")
   leia(nome)
   se produtoExiste(nome) > 0 então
      escreval("O produto ", produtos[quantidadeProdutosCadastrados].nome, " Já existe no cadastro!")
   senao
      produtos[ quantidadeProdutosCadastrados].nome <- nome
      escreval( "Informe o preço do produto")
      leia    ( produtos[quantidadeProdutosCadastrados].preco)
      escreval( "Informe o estoque do produto")
      leia    ( produtos[quantidadeProdutosCadastrados].estoque)
      quantidadeProdutosCadastrados <- quantidadeProdutosCadastrados+1
      escreval( "Produto cadastrado com sucesso")
   fimSe
fimProcedimento

funcao consultarEstoque( nome : caractere ) : inteiro
var
   contador  : inteiro
   resultado : inteiro
inicio
   para  contador  <- 1 ate quantidadeProdutosCadastrados faca
      se nome      =  produtos[contador].nome então
         resultado <- produtos[contador].estoque
         interrompa()
      fimSe
   fimPara
   retorne resultado
fimFuncao

funcao atualizarEstoque ( opcao2 : caractere ; quantidade : inteiro ) : inteiro
var
   contador, c : inteiro
inicio
   para contador  <- 1 ate quantidadeProdutosCadastrados faca
      se opcao2   = "R" então
         produtos[contador].estoque <-  produtos[contador].estoque - quantidade
         c <- produtos[contador].estoque
         interrompa
      senao
         se opcao2 = "A" então
            produtos[contador].estoque <-  produtos[contador].estoque + quantidade
            c <- produtos[contador].estoque
            interrompa
         fimSe
      fimse
   fimPara
   retorne c
fimfuncao

Inicio

   quantidadeProdutoscadastrados <- 1
   repita
      limpatela("")
      escreval (" [0] - Sair  Do ProGrama")
      escreval (" [1] - Cadastrar produto")
      escreval (" [2] - consultar produto")
      escreval (" [3] - atualizar estoque")
      escreval (" [4] - listar   produtos")
      escreval ("Escolha uma opcao "      )
      leia     ( opcao                    )
      limpatela("")
      escolha opcao
      caso 1
         se quantidadeProdutosCadastrados <= quantidadeMaximaProdutos então
            cadastrarProduto()
         senao
            escreval(" Limite de cadastro atingido")
         fimSe
      caso 2
         escreval ("Informe o nome do produto que deseja consultar o estoque")
         leia( nome )
         r <- produtoExiste(nome)
         se r > 0 então
            r <- consultarEstoque(nome)
            escreval(" A quantidade de estoque do produto ", nome, " é ", r:1)
         senao
            escreval(" Produto não cadastrado.")
         fimSe
      caso 3
         escreval ("Informe o nome do produto que deseja atualizar o estoque")
         leia( nome )
         r <- produtoExiste(nome)
         se r > 0 então
            escreval( "[R] - retirar  " )
            escreval( "[A] - adicionar" )
            leia    ( opcao2            )
            opcao2 <- maiusc( opcao2    )
            se opcao2 = "R" então
               escreval ("Quanto gostaria de retirar" )
               leia     ( quantidade                  )
               r <- atualizarEstoque(opcao2,quantidade)
               escreval("O novo estoque é de ", nome, " é ", r:1)
            senao
               se opcao2 = "A" então
                  escreval ("Quanto gostaria de adicionar")
                  leia     ( quantidade                   )
                  r <- atualizarEstoque(opcao2,quantidade )
                  escreval("O novo estoque é de ", nome, " é ", r:1)
               fimse
            fimse
         senao
            escreval(" Produto não cadastrado.")
         fimSe
      caso 4
        EscrevaL("   Listando Todos Prod Cadastrados"  )
        para a de 1 ate quantidadeProdutosCadastrados-1 faca
          EscrevaL("Dados Do ",a,"º Produto"           )
          escreval("Produto -: ",produtos[a].nome      )
          escreval("PreCo ---:" ,produtos[a].preco   :5)
          escreval("PreCo ---:" ,produtos[a].estoque :5)
          EscrevaL("")
        fimpara
      fimescolha
      se opcao <> 0 então
        EscrevaL("")
        EscrevaL("   Tecle Enter ")
        leia(a)
      fimse
   ate ( opcao = 0 )

Fimalgoritmo

ou de algum outro modo que melhor lhe agradar , com as formatações , textos de mensagens e opções de pausas para ver os resultados .

devair1010 · 18 de outubro de 2023

@Eli Almeidaa se você quiser pode marcar essa minha resposta de cima , no #10 , como solução . . !

Simon Viegas · 18 de outubro de 2023

@Eli Almeidaa, teu código já está muito bom. Para efeito didático, aso queira treinar ou usar princípio no teu próprio código, segue um exemplo de possível refatoração no algoritmo. Vai um passo a passo inicial (que serve de modo genérico).

[0] Escopo inicial

Acho interessante deixar o enunciado no código... Facilita as consultas:

algoritmo "Gerenciamento de Produtos v0.3"
// Disciplina  :
// Professor   :
// Autor(a)    : Eli Almeidaa
// Data atual  : 18/10/2023
// ENUNCIADO:
//Você foi designado para criar um programa em portugol que ajude uma loja a
//gerenciar seu estoque de produtos eletrônicos. A loja possui um catálogo de
//produtos, cada um representado por um vetor de registro com as seguintes
//informações:
//* Nome do produto (string)
//* Preço unitário (real)
//* Quantidade em estoque (inteiro)

//Sua tarefa é escrever um programa que realize as seguintes operações através
//de funções:
//* Cadastro de Produto: Crie uma função que permita ao usuário cadastrar um novo
//produto, informando o nome, preço unitário e quantidade em estoque. Os dados
//devem ser armazenados no vetor de produtos.
//* Consulta de Estoque: Crie uma função que permita ao usuário consultar o
//estoque de um produto específico, informando o nome do produto. A função deve
//retornar a quantidade em estoque desse produto.
//* Atualização de Estoque: Crie uma função que permita ao usuário atualizar o
//estoque de um produto existente, informando o nome do produto e a quantidade
//a ser adicionada ou subtraída do estoque.
//Listagem de Produtos: Crie uma função que liste todos os produtos cadastrados,
//exibindo o nome, preço unitário e quantidade em estoque de cada um.
inicio

fimAlgoritmo

[1] DECLARAÇÃO DAS VARIÁVEIS E CONSTANTES GLOBAIS

18 horas atrás, Eli Almeidaa disse:

const
   quantidadeMaximaProdutos = 2

tipo
   loja = registro
      nome: caractere
      preco: real
      estoque: inteiro
   fimRegistro

var
   produtos: vetor [1..quantidadeMaximaProdutos] de loja
   quantidadeProdutosCadastrados, opcao, r, quantidade : inteiro
   nome, opcao2  : caractere

1.1 as constantes deixar todo em MAIÚSCULO, para justamente diferenciar das variáveis;

1.2 em relação ao tipo, você está cadastrando produtos, e não lojas;

1.3 variáveis que são declaradas em assinaturas de métodos NÃO devem ser declaradas novamente como globais. Você aí está apenas "duplicando". (Sim! vai ficar uma variável global, e outra local para cada caso.);

1.4 alguns dessas variáveis deveriam ser declaradas dentro do métodos, e não como globais.

De um modo simplificado poderia ficar assim:

const
   QTD_MAX_PRODUTOS = 2

tipo
   t_Produto = registro
      nome : caractere
      preco : real
      estoque : inteiro
   fimRegistro

var
   produtos : vetor [1..QTD_MAX_PRODUTOS] de t_Produto
   opcao, qtdProdutos : inteiro

Só isso que é global. O restante seria variáveis locais.

[2] Simplificação do menu

18 horas atrás, Eli Almeidaa disse:

      escreval("[1]- Cadastrar produto")
      escreval("[2]- consultar produto")
      escreval("[3]- atualizar estoque")
      escreval ("[4]- listar produtos")
      
      escreval("Escolha uma opcao")
      leia (opcao)
      escolha opcao
      caso 1
         se quantidadeProdutosCadastrados <= quantidadeMaximaProdutos então
            cadastrarProduto()
         senao
            escreval(" Limite de cadastro atingido")
         fimSe
      caso 2
         escreval ("Informe o nome do produto que deseja consultar o estoque")
         leia(nome)
         r <- produtoExiste(nome)
         se r > 0 então
            r <- consultarEstoque(nome)
            escreval(" A quantidade de estoque do produto ", nome, " é ", r:1)
         senao
            escreval(" Produto não cadastrado.")
         fimSe
      caso 3
         escreval ("Informe o nome do produto que deseja atualizar o estoque")
         leia(nome)
         r <- produtoExiste(nome)
         se r > 0 então
            escreval ("[R] - retirar")
            escreval("[A] - adicionar")
            leia(opcao2)
            opcao2 <- maiusc(opcao2)
            se opcao2 = "R" então
               escreval ("Quanto gostaria de retirar")
               leia(quantidade)
               r <- atualizarEstoque(opcao2,quantidade)
               escreval("O novo estoque é de ", nome, " é ", r:1)
            senao
               se opcao2 = "A" então
                  escreval ("Quanto gostaria de adicionar")
                  leia(quantidade)
                  r <- atualizarEstoque(opcao2,quantidade)
                  escreval("O novo estoque é de ", nome, " é ", r:1)
               fimse
            fimse
         senao
            escreval(" Produto não cadastrado.")
         fimSe
         
      fimescolha

Deixar o menu cru. Exemplo:

inicio
   qtdProdutos <- 0

   repita
      escrevaL("[1]- Cadastrar produto")
      escrevaL("[2]- Consultar produto")
      escrevaL("[3]- Atualizar estoque")
      escrevaL("[4]- Listar produtos")

      escrevaL("Escolha uma opcao")
      leia (opcao)
      
      escolha opcao
      caso 1
         cadastrarProduto()
      caso 2
         consultarEstoque()
      caso 3
         atualizarEstoque()
      caso 4
         listarProdutos()
      fimEscolha
   ate (opcao = 0)
fimAlgoritmo

Aí dentro de cada método constrói a sua lógica. Sugiro começar pela listagem, pois ela ajuda a ver se está cadastrando certo. Depois o cadastro (usando o listar como apoio). O código ficará muito mais limpo.

[3] Listagem de Produtos

Vai criando os métodos aos poucos. Sempre começando de algo mais simples e indo incrementando os detalhes depois. Exemplo:

procedimento listarProdutos()
var
   contador : inteiro
inicio
   escrevaL("Produtos cadastrados :")

   para contador <- 1 ate qtdProdutos faca
      escrevaL("Nome    : ", produtos[contador].nome)
      escrevaL("Preço   : R$ ", produtos[contador].preco:1:2)
      escrevaL("Estoque : ", produtos[contador].estoque:1)
      escrevaL()
   fimPara
fimProcedimento

Adendo: o código não precisa ficar pronto de primeira, vai fazendo diversos testes até chegar numa versão que ache que ficou legal.

Simples e direto. Aí, vai inserindo as validações. Exemplo:

procedimento listarProdutos()
var
   contador : inteiro
inicio
   se (qtdProdutos <= 0) então
      escrevaL("Não há produtos cadastrados")
   senao
      escrevaL("Produtos cadastrados :")

      para contador <- 1 ate qtdProdutos faca
         escrevaL("Nome    : ", produtos[contador].nome)
         escrevaL("Preço   : R$ ", produtos[contador].preco:1:2)
         escrevaL("Estoque : ", produtos[contador].estoque:1)
         escrevaL()
      fimPara
   fimSe
fimProcedimento

[4] Cadastro de Produtos

Segue outro exemplo de método:

procedimento cadastrarProduto()
var
   novoProduto : t_Produto
inicio
   escrevaL("Informe o nome do produto")
   leia(novoProduto.nome)
   escrevaL("Informe o preço do produto")
   leia(novoProduto.preco)
   escrevaL("Informe o estoque do produto")
   leia(novoProduto.estoque)
   qtdProdutos <- qtdProdutos+1
   produtos[qtdProdutos] <- novoProduto
   escrevaL("Produto cadastrado com sucesso")
fimProcedimento

Da mesma forma vai inserindo as validações aos poucos:

funcao vetorCheio() : logico
var
   retorno : logico
inicio
   retorno <- VERDADEIRO

   se (qtdProdutos < QTD_MAX_PRODUTOS) então
      retorno <- FALSO
   fimSe

   retorne retorno
fimFuncao

funcao produtoExiste (nome:caractere) : logico
var
   contador : inteiro
   existe : logico
inicio
   existe <- FALSO

   para contador <- 1 ate qtdProdutos faca
      se (produtos[contador].nome = nome) então
         existe <- VERDADEIRO
         interrompa()
      fimSe
   fimPara

   retorne existe
fimFuncao

procedimento cadastrarProduto()
var
   novoProduto : t_Produto
inicio
   se (vetorCheio()) então
      escrevaL("Não há mais espaço no vetor para cadastro de novos produtos")
   senao
      escrevaL("Informe o nome do produto")
      leia(novoProduto.nome)

      se (produtoExiste(novoProduto.nome)) então
         escrevaL("Já existe um produto com o nome '", novoProduto.nome, "' no cadastro!")
      senao
         escrevaL("Informe o preço do produto")
         leia(novoProduto.preco)
         escrevaL("Informe o estoque do produto")
         leia(novoProduto.estoque)
         qtdProdutos <- qtdProdutos+1
         produtos[qtdProdutos] <- novoProduto
         escrevaL("Produto cadastrado com sucesso")
      fimSe
   fimSe
fimProcedimento

[5] Alternativa para forma de validar

Resumo: Textos dentro do métodos principais X textos dentro dos métodos de validação

O código até aqui estaria com algo assim:

algoritmo "Gerenciamento de Produtos v0.3"
// Disciplina  :
// Professor   :
// Autor(a)    : Eli Almeidaa
// Data atual  : 18/10/2023
// ENUNCIADO:
...
const
   QTD_MAX_PRODUTOS = 2

tipo
   t_Produto = registro
      nome : caractere
      preco : real
      estoque : inteiro
   fimRegistro

funcao existemProdutosCadastrados() : logico
var
   retorno : logico
inicio
   se (qtdProdutos > 0) então
      retorno <- VERDADEIRO
   senao
      retorno <- FALSO
   fimSe

   retorne retorno
fimFuncao

funcao vetorCheio() : logico
var
   retorno : logico
inicio
   retorno <- VERDADEIRO

   se (qtdProdutos < QTD_MAX_PRODUTOS) então
      retorno <- FALSO
   fimSe

   retorne retorno
fimFuncao

funcao produtoExiste (nome:caractere) : logico
var
   contador : inteiro
   existe : logico
inicio
   existe <- FALSO

   para contador <- 1 ate qtdProdutos faca
      se (produtos[contador].nome = nome) então
         existe <- VERDADEIRO
         interrompa()
      fimSe
   fimPara

   retorne existe
fimFuncao

procedimento cadastrarProduto()
var
   novoProduto : t_Produto
inicio
   se (vetorCheio()) então
      escrevaL("Não há mais espaço no vetor para cadastro de novos produtos")
   senao
      escrevaL("Informe o nome do produto")
      leia(novoProduto.nome)

      se (produtoExiste(novoProduto.nome)) então
         escrevaL("Já existe um produto com o nome '", novoProduto.nome, "' no cadastro!")
      senao
         escrevaL("Informe o preço do produto")
         leia(novoProduto.preco)
         escrevaL("Informe o estoque do produto")
         leia(novoProduto.estoque)
         qtdProdutos <- qtdProdutos+1
         produtos[qtdProdutos] <- novoProduto
         escrevaL("Produto cadastrado com sucesso")
      fimSe
   fimSe
fimProcedimento

procedimento listarProdutos()
var
   contador : inteiro
inicio
   se (não existemProdutosCadastrados()) então
      escrevaL("Não há produtos cadastrados")
   senao
      escrevaL("Produtos cadastrados :")

      para contador <- 1 ate qtdProdutos faca
         escrevaL("Nome    : ", produtos[contador].nome)
         escrevaL("Preço   : R$ ", produtos[contador].preco:1:2)
         escrevaL("Estoque : ", produtos[contador].estoque:1)
         escrevaL()
      fimPara
   fimSe
fimProcedimento

var
   produtos : vetor [1..QTD_MAX_PRODUTOS] de t_Produto
   opcao, qtdProdutos : inteiro
inicio
   qtdProdutos <- 0

   repita
      escrevaL("[1]- Cadastrar produto")
      escrevaL("[2]- Consultar produto")
      escrevaL("[3]- Atualizar estoque")
      escrevaL("[4]- Listar produtos")

      escrevaL("Escolha uma opcao")
      leia (opcao)

      escolha opcao
      caso 1
         cadastrarProduto()
      caso 2
         consultarEstoque()
      caso 3
         atualizarEstoque()
      caso 4
         listarProdutos()
      fimEscolha
   ate (opcao = 0)
fimAlgoritmo

Ou seja: o método de cadastro que exibe a possível mensagem de erro.

Mas poderia colocar o texto do "erro na validação" dentro do próprio método que valida, veja:

funcao vetorCheio() : logico
var
   retorno : logico
inicio
   retorno <- FALSO

   se (qtdProdutos >= QTD_MAX_PRODUTOS) então
      escrevaL("Não há mais espaço no vetor para cadastro de novos produtos")
      retorno <- VERDADEIRO
   fimSe

   retorne retorno
fimFuncao

funcao produtoExiste (nome:caractere) : logico
var
   contador : inteiro
   existe : logico
inicio
   existe <- FALSO

   para contador <- 1 ate qtdProdutos faca
      se (produtos[contador].nome = nome) então
         escrevaL("Já existe um produto com o nome '", nome, "' no cadastro!")
         existe <- VERDADEIRO
         interrompa()
      fimSe
   fimPara

   retorne existe
fimFuncao

procedimento cadastrarProduto()
var
   novoProduto : t_Produto
inicio
   escrevaL("Informe o nome do produto")
   leia(novoProduto.nome)

   se ((não vetorCheio()) E (não produtoExiste(novoProduto.nome))) então
      escrevaL("Informe o preço do produto")
      leia(novoProduto.preco)
      escrevaL("Informe o estoque do produto")
      leia(novoProduto.estoque)
      qtdProdutos <- qtdProdutos+1
      produtos[qtdProdutos] <- novoProduto
      escrevaL("Produto cadastrado com sucesso")
   fimSe
fimProcedimento

Dessa forma o texto fica centralizado em um lugar só, ou seja, se outros métodos principais precisaram utilizar de uma mesma validação, não será necessário escrever a mensagem de erro. É um duplo ganho.

1. não precisa reescrever a lógica de validação, basta invocar o método que deseja;

2. não precisa reescrever o texto de resposta, pois o texto está já no método que valida.

Testando:

Se já existir o nome:

Se estiver cheio:

Se estiver cheio e for um nome repetido:

Veja que o programa pergunta o nome do produto mesmo se eventualmente estiver cheio... Aí vai tudo da forma que deseja que o programa se comporte, por exemplo, você pode querer que não pergunte o nome se já estiver cheio, aí precisaria ajustar o código para esse novo comportamento.

Daí poderia fazer o mesmo com o lista, ou seja, o texto:

escrevaL("Não há produtos cadastrados")

que está dentro do listarProdutos() e passaria então a ficar no existemProdutosCadastrados(). Após ajustaria o listarProdutos() para essa nova mudança (ficando análogo ao cadastrarProduto()).

O importante que a estrutura do código fique homogênea, ou seja, fica estranho uma método ter um padrão, e outro ter um diferente. Procurar deixar uniforme.

Eli Almeida · 21 de outubro de 2023

@Simon Viegas , segui suas dicas em alguns itens como colocar o nome da constante em letra maiúscula, deixar o menu cru, troquei o nome do registro para produto, fiz a opção 4 desse jeito aqui, não sei se estaria certo também. O código da forma que você está fazendo aí, como criando função existemProdutosCadastrados, função vetorCheio e função produtoExiste, seria a forma mais correta de fazer essa questão? Seria a forma que deixaria o código mais limpo e mais fácil de entender?

Algoritmo "Gerenciamento de Produtos"

const
   QUANTIDADE_MAX_PRODUTOS = 2

tipo
   produto = registro
      nome: caractere
      preco: real
      estoque: inteiro
   fimRegistro

var
   produtos: vetor [1..QUANTIDADE_MAX_PRODUTOS] de produto
   quantidadeProdutosCadastrados, opcao: inteiro

funcao produtoExiste(nome:caractere):inteiro
var
   resultado : inteiro
   contador : inteiro
inicio

   para contador <- 1 ate quantidadeProdutosCadastrados faca
      se nome = produtos[contador].nome então
         resultado <- contador
         interrompa()
      fimse
   fimPara
   retorne resultado
fimFuncao

procedimento cadastrarProduto()
var
   nome : caractere
inicio
   se quantidadeProdutosCadastrados <= QUANTIDADE_MAX_PRODUTOS então

      escreval("Informe o nome do produto")
      leia(nome)
      se (produtoExiste(nome) > 0) então
         escreval("O produto ", produtos[quantidadeProdutosCadastrados].nome, " Já existe no cadastro!")
      senao
         produtos[quantidadeProdutosCadastrados].nome <- nome
         escreval("Informe o preço do produto")
         leia(produtos[quantidadeProdutosCadastrados].preco)
         escreval("Informe o estoque do produto")
         leia(produtos[quantidadeProdutosCadastrados].estoque)
         quantidadeProdutosCadastrados <- quantidadeProdutosCadastrados+1
         escreval("Produto cadastrado com sucesso")
      fimSe
   senao
      escreval(" Limite de cadastro atingido")
   fimSe
fimProcedimento

procedimento consultarEstoque()
var
   nome:caractere
   contador : inteiro
   resultado:inteiro
   r : inteiro
inicio
   escreval ("Informe o nome do produto que deseja consultar o estoque")
   leia(nome)
   r <- produtoExiste(nome)
   se r > 0 então
      para  contador <- 1 ate quantidadeProdutosCadastrados faca
         se nome = produtos[contador].nome então
            resultado <- produtos[contador].estoque
            escreval(" A quantidade de estoque do produto ", nome, " é ",  resultado:1)
            interrompa()
         fimSe
      fimPara
   senao
      escreval(" Produto não cadastrado.")
   fimSe
fimProcedimento

procedimento atualizarEstoque ()
var
   nome : caractere
   opcao2:caractere
   quantidade:inteiro
   contador, c, r : inteiro
inicio
   escreval ("Informe o nome do produto que deseja atualizar o estoque")
   leia(nome)
   r <- produtoExiste(nome)
   se r > 0 então
      escreval ("[R] - retirar")
      escreval("[A] - adicionar")
      leia(opcao2)
      opcao2 <- maiusc(opcao2)
      para contador <- 1 ate quantidadeProdutosCadastrados faca
         se opcao2 = "R" então
            escreval ("Quanto gostaria de retirar")
            leia(quantidade)

            produtos[contador].estoque <-  produtos[contador].estoque - quantidade
            c <- produtos[contador].estoque
            escreval("O novo estoque é de ", nome, " é ",  c:1)
            interrompa
         senao
            se opcao2 = "A" então
               escreval ("Quanto gostaria de adicionar")
               leia     (quantidade)
               produtos[contador].estoque <-  produtos[contador].estoque + quantidade
               c <- produtos[contador].estoque
               escreval("O novo estoque é de ", nome, " é ",  c:1)
               interrompa
            fimSe
         fimSe
      fimPara
   senao
      escreval(" Produto não cadastrado.")
   fimSe
fimProcedimento

     procedimento listarProduto()
var
   contador : inteiro
   r, y : inteiro
   nome : caractere
inicio

   y <- quantidadeProdutosCadastrados
   quantidadeProdutosCadastrados <- 1
   nome <- ""
   r <- produtoExiste(nome)
   se (r = 0) e (r <> 1) então
      quantidadeProdutosCadastrados <- y
      para contador <- 1 ate quantidadeProdutosCadastrados-1 faca
         se  produtos[contador].nome <> "" então
            escreval("Nome :", produtos[contador].nome)
            escreval("Preço :", produtos[contador].preco)
            escreval("Estoque :", produtos[contador].estoque)
         fimse
      fimPara
   senao
      escreval("Não há produtos cadastrados.")
      escreval()
   fimSe

fimProcedimento

Inicio
   quantidadeProdutoscadastrados <- 1
   repita

      escreval("[0] - Sair ")
      escreval("[1]- Cadastrar produto")
      escreval("[2]- consultar produto")
      escreval("[3]- atualizar estoque")
      escreval ("[4]- listar produtos")

      escreval("Escolha uma opcao")
      leia (opcao)
      escolha opcao
      caso 1
         cadastrarProduto()

      caso 2
         consultarEstoque()

      caso 3
         atualizarEstoque()

      caso 4
         listarProduto()

      fimescolha
   ate (opcao=0)

Fimalgoritmo

Simon Viegas · 23 de outubro de 2023

Em 21/10/2023 às 15:14, Eli Almeidaa disse:

O código da forma que você está fazendo aí, como criando função existemProdutosCadastrados, função vetorCheio e função produtoExiste, seria a forma mais correta de fazer essa questão?

Assim..., não seria "a" forma mais correta, seria apenas "umas" sugestões. Seria tentar seguir uma lógica geral e mais uniforme.

Em 21/10/2023 às 15:14, Eli Almeidaa disse:

Seria a forma que deixaria o código mais limpo e mais fácil de entender?

Isso. A proposta é que o código sempre faça o maior sentido possível. Buscar ser coerente. Pois a medida que o código vai crescendo, mais complicado ficará para entender todo o código, ou seja, tendo uma coerência geral, fica mais fácil deduzir "o que seria" cada coisa. E se uma coisa não existir, você já entenderá mais facilmente o que precisaria ser feito.

Veja o código abaixo:

Em 21/10/2023 às 15:14, Eli Almeidaa disse:

funcao produtoExiste(nome:caractere):inteiro
var
   resultado : inteiro
   contador : inteiro
inicio

   para contador <- 1 ate quantidadeProdutosCadastrados faca
      se nome = produtos[contador].nome então
         resultado <- contador
         interrompa()
      fimse
   fimPara
   retorne resultado
fimFuncao

A função chama-se "produtoExiste", mas analisando o código verificam-se que na verdade ela serve para "retornar a posição do vetor onde está o produto que contenha aquele nome". Entende a diferença? Ela tem uma nomenclatura que indica uma coisa, mas está fazendo outra função (objetivo) diferente. Fica estranho. Quando mais coerente, mais simples vai ficar...

Apenas ajuste a função. Em vez de retornar a posição, fazer o que tem que fazer: retornar se existe ou não. Veja:

Em 18/10/2023 às 15:53, Simon Viegas disse:
funcao produtoExiste (nome:caractere) : logico
var
   contador : inteiro
   retorno : logico
inicio
   retorno <- FALSO

   para contador <- 1 ate qtdProdutos faca
      se (produtos[contador].nome = nome) então
         retorno <- VERDADEIRO
         interrompa()
      fimSe
   fimPara

   retorne retorno
fimFuncao
Obs.: eu mudei o nome da variável auxiliar de "existe" para "retorno", justamente para manter a coerência do restante do código.

"Estou verificando se algo existe, logo espero que me retorne se existe ou não".

Tem também a questão de "onde colocar a mensagem de erro". Aí dê uma olhada na minha postagem anterior no trecho citado abaixo:

Em 18/10/2023 às 15:53, Simon Viegas disse:

Ou seja: o método de cadastro que exibe a possível mensagem de erro.

Mas poderia colocar o texto do "erro na validação" dentro do próprio método que valida, veja:

Observe que essa característica de "retornar a posição de um produto" poderia ser útil, por exemplo, na hora de atualizar. Aí só aproveitar:

funcao buscaPosicaoProduto(nome:caractere):inteiro
var
   resultado : inteiro
   contador : inteiro
inicio
   resultado <- 0

   para contador <- 1 ate quantidadeProdutosCadastrados faca
      se (nome = produtos[contador].nome) então
         resultado <- contador
         interrompa()
      fimse
   fimPara

   retorne resultado
fimFuncao

Ou seja: passando o nome, já terá a posição no vetor que precisar atualizar o produto. Se não achar, vai retornar 0.

CORREÇÕES IMPORTANTES:

1. iniciando com a quantidade correta

Em 21/10/2023 às 15:14, Eli Almeidaa disse:
Inicio
   quantidadeProdutoscadastrados <- 1

Lembre-se da coerência!!! Oras! se não tem nenhum produto cadastrado, como raios vai começar com 1? Tem que ser com 0!!! . (Daí tem que ajustar todo restante do código onde possa ter efeito.)

2. Corrija o malabarismo da função de listar

Em 21/10/2023 às 15:14, Eli Almeidaa disse:

procedimento listarProduto()
var
   contador : inteiro
   r, y : inteiro
   nome : caractere
inicio
   y <- quantidadeProdutosCadastrados
   quantidadeProdutosCadastrados <- 1
   nome <- ""
   r <- produtoExiste(nome)
   se (r = 0) e (r <> 1) então
      quantidadeProdutosCadastrados <- y

Para visualizar a complexidade da coisa: y recebe a quantidade de produtos, depois a quantidade de produtos do programa em si passa ser 1, depois verifica se tem um produto "sem nome" existe no vetor, depois está verificando se o resultado (da existência) retornou especificamente 0, e que ao mesmo tempo essa mesma variável seja diferente de 1 (se é 0, necessariamente será diferente de 1).....

O que você queria verificar? Seria "se existe algum produto cadastrado"?... Logo, seria só verificar a quantidade de produtos:

procedimento listarProdutos()
var
   contador : inteiro
inicio
   se (quantidadeProdutoscadastrados > 0) então
      escrevaL("Não há produtos cadastrados")
   senao
      escrevaL("Produtos cadastrados :")

      para contador <- 1 ate qtdProdutos faca
         escrevaL("Nome    : ", produtos[contador].nome)
         escrevaL("Preço   : R$ ", produtos[contador].preco:1:2)
         escrevaL("Estoque : ", produtos[contador].estoque:1)
         escrevaL()
      fimPara
   fimSe
fimProcedimento

Daí, só criei uma função para deixar mais organizado e elegante:

Em 18/10/2023 às 15:53, Simon Viegas disse:

procedimento listarProdutos()
var
   contador : inteiro
inicio
   se (não existemProdutosCadastrados()) então
      escrevaL("Não há produtos cadastrados")
   senao
      escrevaL("Produtos cadastrados :")

      para contador <- 1 ate qtdProdutos faca
         escrevaL("Nome    : ", produtos[contador].nome)
         escrevaL("Preço   : R$ ", produtos[contador].preco:1:2)
         escrevaL("Estoque : ", produtos[contador].estoque:1)
         escrevaL()
      fimPara
   fimSe
fimProcedimento

Adendo: no código acima também entra a questão de "onde deixar a mensagem de erro" (que citei que tem na postagem anterior), ou seja, pedi para verificar se existe ou não produtos, e a mensagem ficou fora da função que verifica. Se tiver 10 lugares diferentes que chama essa função e precisar de uma mensagem de erro, teria que escrever 10 vezes a mensagem. Se precisa modificar a mensagem, teria que modificar 10x... se deixar dentro da própria função, aí ficaria centralizado só lá. Só reler a postagem anterior também. Vai analisando e deixando da forma que fique mais organizada... lembrando-se sempre de manter um padrão uniforme para as funções.

Conteúdo da função existemProdutosCadastrados:

Em 18/10/2023 às 15:53, Simon Viegas disse:

funcao existemProdutosCadastrados() : logico
var
   retorno : logico
inicio
   se (quantidadeProdutoscadastrados > 0) então
      retorno <- VERDADEIRO
   senao
      retorno <- FALSO
   fimSe

   retorne retorno
fimFuncao

Tudo é uma questão de entender os contextos... essa função poderia se chamar "listaVazia()" ou algo do tipo, por exemplo... nesse caso o resultado seria invertido ("se é maior que 0, então é FALSO") e onde for usar essa função seria ajustado para tal característica.

Adendo: propositalmente deixei um erro na verificação no listarProdutos... lembre-se: as coisas tem que fazer sentido... Ao ler teria que vir a mente algo como: "Ham! como assim maior que 0". Oras! para "não haver produtos cadastrados, a quantidade tem que ser = 0". Lá está > 0 (se estiver maior, quer dizer que tem produtos!).

Por aí vai.

Eli Almeida · 27 de outubro de 2023

@Simon Viegas, usei como base o pedaço do código que você já tinha postado. Modifiquei o listarProdutos e cadastrarProduto, agora se o vetor estiver cheio, já não digita o nome do produto e se digitar um nome que já existe, não retorna para o menu imediatamente, aí pede para digitar um produto novamente. Acrescentei o procedimento consultarEstoque e atualizarEstoque. Não sei se estaria certo assim:

Algoritmo "Gerenciamento de Produtos v0.3"

// Disciplina  :
// Professor   :
// Autor(a)    : Eli Almeidaa
// Data atual  : 18/10/2023
// ENUNCIADO:

const
   QTD_MAX_PRODUTOS = 2

tipo
   t_Produto = registro
      nome : caractere
      preco : real
      estoque : inteiro
   fimRegistro

funcao existemProdutosCadastrados() : logico
var
   retorno : logico
inicio
   retorno <- falso
   se (qtdProdutos > 0) então
      retorno <- VERDADEIRO
   senao
      escrevaL("Não há produtos cadastrados")
      retorno <- FALSO
   fimSe

   retorne retorno
fimFuncao

funcao vetorCheio() : logico
var
   retorno : logico
inicio
   retorno <- FALSO

   se (qtdProdutos >= QTD_MAX_PRODUTOS) então
      escrevaL("Não há mais espaço no vetor para cadastro de novos produtos")
      retorno <- VERDADEIRO
   fimSe

   retorne retorno
fimFuncao

funcao produtoExiste (nome:caractere) : logico
var
   contador : inteiro
   existe : logico
inicio
   existe <- FALSO

   para contador <- 1 ate qtdProdutos faca
      se (produtos[contador].nome = nome) então
         escrevaL("Já existe um produto com o nome '", nome, "' no cadastro!")
         existe <- VERDADEIRO
         interrompa()
      fimSe
   fimPara

   retorne existe
fimFuncao

funcao buscaPosicaoProduto(nome:caractere):inteiro
var
   resultado : inteiro
   contador : inteiro
inicio
   resultado <- 0

   para contador <- 1 ate qtdProdutos faca
      se (nome = produtos[contador].nome) então
         resultado <- contador
         interrompa()
      fimse
   fimPara

   retorne resultado
fimFuncao

procedimento cadastrarProduto()
var
   novoProduto : t_Produto
   produtoJaExiste : logico
inicio
   se  vetorCheio = falso então
      repita
         produtoJaExiste <- falso
         escrevaL("Informe o nome do produto")
         leia(novoProduto.nome)
         se produtoExiste(novoProduto.nome) = falso então
            escrevaL("Informe o preço do produto")
            leia(novoProduto.preco)
            escrevaL("Informe o estoque do produto")
            leia(novoProduto.estoque)
            qtdProdutos <- qtdProdutos+1
            produtos[qtdProdutos] <- novoProduto
            escrevaL("Produto cadastrado com sucesso")
         senao
            ProdutoJaExiste <- verdadeiro
         fimSe
      ate (ProdutoJaExiste = falso)
   fimSe
fimProcedimento

procedimento listarProdutos()
var
   contador : inteiro
inicio

   se  existemProdutosCadastrados = verdadeiro então
      escrevaL("Produtos cadastrados :")
      para contador <- 1 ate qtdProdutos faca
         escrevaL("Nome    : ", produtos[contador].nome)
         escrevaL("Preço   : R$ ", produtos[contador].preco:1:2)
         escrevaL("Estoque : ", produtos[contador].estoque:1)
         escrevaL()
      fimPara
   fimSe
fimProcedimento

procedimento consultarEstoque ()
var
   novoProduto : t_Produto
   r:inteiro
inicio
   se  existemProdutosCadastrados = verdadeiro então
      escreval("Informe o nome do produto que gostaria de consultar o estoque")
      leia(novoProduto.nome)
      se  buscaPosicaoProduto(novoProduto.nome)> 0 então
         escreval(" O estoque de ", novoProduto.nome, " é ", produtos[buscaPosicaoProduto(novoProduto.nome)].estoque:1)
      fimSe
   fimse
fimProcedimento

procedimento atualizarEstoque ()
var
   novoProduto: t_Produto
   opcao : caractere
   quantidade: inteiro
inicio
   se  existemProdutosCadastrados = verdadeiro então
      escreval("Informe o nome do produto que gostaria de atualizar o estoque")
      leia(novoProduto.nome)
      se  buscaPosicaoProduto(novoProduto.nome)> 0 então
         escreval ("[A] - adicionar")
         escreval ("[R] - retirar")
         leia(opcao)
         opcao <- maiusc(opcao)
         se opcao = "A" então
            escreval("Quanto gostaria de adicionar?")
            leia(quantidade)
            produtos[buscaPosicaoProduto(novoProduto.nome)].estoque <- produtos[buscaPosicaoProduto(novoProduto.nome)].estoque+quantidade
            escreval("O novo estoque de ", novoProduto.nome, " é ", produtos[buscaPosicaoProduto(novoProduto.nome)].estoque:1)
         senao
            se opcao = "R" então
               escreval("Quanto gostaria de retirar?")
               leia(quantidade)
               produtos[buscaPosicaoProduto(novoProduto.nome)].estoque <- produtos[buscaPosicaoProduto(novoProduto.nome)].estoque-quantidade
               escreval("O novo estoque de ", novoProduto.nome, " é ", produtos[buscaPosicaoProduto(novoProduto.nome)].estoque:1)
            fimse
         fimSe
      fimSE
   fimSe
fimProcedimento

var
   produtos : vetor [1..QTD_MAX_PRODUTOS] de t_Produto
   opcao, qtdProdutos : inteiro

inicio
   qtdProdutos <- 0
   repita
      escrevaL("[1]- Cadastrar produto")
      escrevaL("[2]- Consultar produto")
      escrevaL("[3]- Atualizar estoque")
      escrevaL("[4]- Listar produtos")

      escrevaL("Escolha uma opcao")
      leia (opcao)

      escolha (opcao)
      caso 1
         cadastrarProduto()
      caso 2
         consultarEstoque()
      caso 3
         atualizarEstoque()
      caso 4
         listarProdutos()
      fimEscolha
   ate (opcao = 0)
fimAlgoritmo

Simon Viegas · 29 de outubro de 2023

@Eli Almeidaa, o algoritmo está muito bom! Show de bola!

Complementando, segue algumas dicas/sugestões/revisões gerais de pequenos detalhes. Aí pode ir analisando e implementando o que achar que faz sentido, ou não:

Vou tentar exemplificar sem explicar muito, pois costumo ser muito prolixo...

De:

Em 27/10/2023 às 16:49, Eli Almeidaa disse:
retorno <- falso

Para:

retorno <- FALSO

FALSO e VERDADEIRO são constantes...

De:

Em 27/10/2023 às 16:49, Eli Almeidaa disse:
se  vetorCheio = falso então

Para:

se (não vetorCheio()) então

Daí a mesma lógica para outras estruturas semelhantes.

Simplificando o cadastrarProduto() pela lógica do restante do algoritmo:

De:

Em 27/10/2023 às 16:49, Eli Almeidaa disse:

   se  vetorCheio = falso então
      repita
         produtoJaExiste <- falso
         escrevaL("Informe o nome do produto")
         leia(novoProduto.nome)
         se produtoExiste(novoProduto.nome) = falso então
            escrevaL("Informe o preço do produto")
            leia(novoProduto.preco)
            escrevaL("Informe o estoque do produto")
            leia(novoProduto.estoque)
            qtdProdutos <- qtdProdutos+1
            produtos[qtdProdutos] <- novoProduto
            escrevaL("Produto cadastrado com sucesso")
         senao
            ProdutoJaExiste <- verdadeiro
         fimSe
      ate (ProdutoJaExiste = falso)
   fimSe

Para:

   se (não vetorCheio()) então
      repita
         escrevaL("Informe o nome do produto")
         leia(novoProduto.nome)
         produtoJaExiste <- produtoExiste(novoProduto.nome)
         
         se (não produtoJaExiste) então
            escrevaL("Informe o preço do produto")
            leia(novoProduto.preco)
            escrevaL("Informe o estoque do produto")
            leia(novoProduto.estoque)
            qtdProdutos <- qtdProdutos+1
            produtos[qtdProdutos] <- novoProduto
            escrevaL("Produto cadastrado com sucesso")
         fimSe
      ate (não produtoJaExiste)
   fimSe

De

Em 27/10/2023 às 16:49, Eli Almeidaa disse:
funcao existemProdutosCadastrados() : logico

Para:

funcao vetorVazio() : logico
var
   retorno : logico
inicio
   retorno <- FALSO

   se (qtdProdutos <= 0) então
      escrevaL("Não há produtos cadastrados")
      retorno <- VERDADEIRO
   fimSe

   retorne retorno
fimFuncao

Já que temos vetorCheio()... Pode fazer mais sentido. Caso queira alterar, poderia utilizar o Ctrl+U.

E ir alterando um por um. Lembrando que o valor lógico estaria invertido, teria que também ajustar a lógica. Exemplo:

De:

Em 27/10/2023 às 16:49, Eli Almeidaa disse:

   se  existemProdutosCadastrados = verdadeiro então
      escrevaL("Produtos cadastrados :")

Para:

   se (não vetorVazio()) então
      escrevaL("Produtos cadastrados :")

De:

Em 27/10/2023 às 16:49, Eli Almeidaa disse:

procedimento consultarEstoque ()
var
   novoProduto : t_Produto
   r:inteiro
inicio
   se  existemProdutosCadastrados = verdadeiro então
      escreval("Informe o nome do produto que gostaria de consultar o estoque")
      leia(novoProduto.nome)
      se  buscaPosicaoProduto(novoProduto.nome)> 0 então
         escreval(" O estoque de ", novoProduto.nome, " é ", produtos[buscaPosicaoProduto(novoProduto.nome)].estoque:1)
      fimSe
   fimse
fimProcedimento

Observe que não há um "novo produto" nesse contexto...

Para:

procedimento consultarEstoque()
var
   nomeProduto : caractere
   posProduto : inteiro
inicio
   se (não vetorVazio()) então
      escrevaL("Informe o nome do produto que gostaria de consultar o estoque")
      leia(nomeProduto)
      
      posProduto <- buscaPosicaoProduto(nomeProduto)
      
      se (posProduto > 0) então
         escreval(" O estoque de ", produtos[posProduto].nome, " é ", produtos[posProduto].estoque:1)
      fimSe
   fimse
fimProcedimento

ou

procedimento consultarEstoque()
var
   nomeProduto : caractere
   posProduto : inteiro
   dbProduto : t_Produto
inicio
   se (não vetorVazio()) então
      escrevaL("Informe o nome do produto que gostaria de consultar o estoque")
      leia(nomeProduto)

      posProduto <- buscaPosicaoProduto(nomeProduto)

      se (posProduto > 0) então
         dbProduto <- produtos[posProduto]
         escreval(" O estoque de ", dbProduto.nome, " é ", dbProduto.estoque:1)
      fimSe
   fimse
fimProcedimento

Adendo: infelizmente o VisualG NÃO PERMITE retornar um registro por uma função. Algo assim:

funcao buscaProduto(nome:caractere) : t_Produto

Mas consegue compreender como isso seria útil para esse ou outros contextos? Infelizmente não rola!

Até dá para fazer um malabarismo utilizando uma variável global, mas acho meio deselegante, para não dizer: armengue . Veja:

var
   produtos : vetor [1..QTD_MAX_PRODUTOS] de t_Produto
   opcao, qtdProdutos : inteiro
   retornoProduto : t_Produto

Aí a função poderia ficar:

funcao buscaProdutoPorNome (nome:caractere) : logico
var
   posProduto : inteiro
   retorno : logico
inicio
   retorno <- FALSO
   posProduto <- buscaPosicaoProduto(nome)

   se (posProduto > 0) então
      retornoProduto <- produtos[posProduto] //aqui utilizando uma variável global para superar a limitação do VisualG
      retorno <- VERDADEIRO
   fimSe
   
   retorne retorno
fimFuncao

E usar algo como:

procedimento consultarEstoque()
var
   nomeProduto : caractere
   posProduto : inteiro
   dbProduto : t_Produto
inicio
   se (não vetorVazio()) então
      escrevaL("Informe o nome do produto que gostaria de consultar o estoque")
      leia(nomeProduto)

      se (buscaProdutoPorNome(nomeProduto)) então
         dbProduto <- retornoProduto //esse variável à direita foi atulizada na função acima
         escreval(" O estoque de ", dbProduto.nome, " é ", dbProduto.estoque:1)
      fimSe
   fimse
fimProcedimento

***Assim como no teu código original, não está sendo tratado a questão do comportamento do que fazer caso não encontre o produto... precisa pensar em algo.***

Por aí vai... tem mais coisa que por ir futucando e "melhorando". Exemplo:

produtos[buscaPosicaoProduto(novoProduto.nome)].estoque <- produtos[buscaPosicaoProduto(novoProduto.nome)].estoque+quantidade

Para evitar ficar chamando a função de busca várias vezes, como já citado, copia o valor:

posProduto <- buscaPosicaoProduto(novoProduto.nome)

Vá tentado refinar o código por completo. Aí se tiver dúvidas posta, ou posta o código completo atual para podermos analisar outros "pequenos detalhes".

Eli Almeida · 9 de novembro de 2023

@Simon Viegas, segui as suas dicas alterei o código. E acrescentei a função produtoCadastrado para verificar se o produto existe no cadastro, caso não, vai aparecer a mensagem "Produto não cadastrado", mas só vai aparecer se houver um produto cadastrado primeiro, aí depois vai em consultar estoque e digitar um produto com nome diferente do que já está cadastrado.

Não consegui pensar em uma lógica para usar os valores verdadeiro e falso, como você já vinha fazendo para retornar um valor lógico para essa função. Fiz assim, não sei se está correto:

Algoritmo "Gerenciamento de Produtos v0.3"

// Disciplina  :
// Professor   :
// Autor(a)    : Eli Almeidaa
// Data atual  : 18/10/2023
// ENUNCIADO:

const
   QTD_MAX_PRODUTOS = 2

tipo
   t_Produto = registro
      nome : caractere
      preco : real
      estoque : inteiro
   fimRegistro

funcao vetorVazio() : logico
var
   retorno : logico
inicio
   retorno <- FALSO
   se (qtdProdutos <= 0) então
      escrevaL("Não há produtos cadastrados")
      retorno <- VERDADEIRO
   senao
      retorno <- FALSO
   fimSe

   retorne retorno
fimFuncao

funcao vetorCheio() : logico
var
   retorno : logico
inicio
   retorno <- FALSO

   se (qtdProdutos >= QTD_MAX_PRODUTOS) então
      escrevaL("Não há mais espaço no vetor para cadastro de novos produtos")
      retorno <- VERDADEIRO
   fimSe

   retorne retorno
fimFuncao


funcao produtoExiste (nome:caractere) : logico
var
   contador : inteiro
   existe : logico
inicio
   existe <- FALSO

   para contador <- 1 ate qtdProdutos faca
      se (produtos[contador].nome = nome) então
         escrevaL("Já existe um produto com o nome '", nome, "' no cadastro!")
         existe <- VERDADEIRO
         interrompa()
      fimSe
   fimPara

   retorne existe
fimFuncao

funcao buscaPosicaoProduto(nome:caractere):inteiro
var
   resultado : inteiro
   contador : inteiro
inicio
   resultado <- 0

   para contador <- 1 ate qtdProdutos faca
      se (nome = produtos[contador].nome) então
         resultado <- contador
         interrompa()
      fimse
   fimPara

   retorne resultado
fimFuncao

procedimento cadastrarProduto()
var
   novoProduto : t_Produto
   produtoJaExiste : logico
inicio
   se (não vetorCheio()) então
      repita
         produtoJaExiste <- FALSO
         escrevaL("Informe o nome do produto")
         leia(novoProduto.nome)
         produtoJaExiste <- produtoExiste(novoProduto.nome)
         se (não produtoJaExiste) então
            escrevaL("Informe o preço do produto")
            leia(novoProduto.preco)
            escrevaL("Informe o estoque do produto")
            leia(novoProduto.estoque)
            qtdProdutos <- qtdProdutos+1
            produtos[qtdProdutos] <- novoProduto
            escrevaL("Produto cadastrado com sucesso")
         fimSe
      ate (não produtoJaExiste)
   fimse
fimProcedimento

procedimento listarProdutos()
var
   contador : inteiro
inicio
   se(não vetorVazio ()) então
      escrevaL("Produtos cadastrados :")
      para contador <- 1 ate qtdProdutos faca
         escrevaL("Nome    : ", produtos[contador].nome)
         escrevaL("Preço   : R$ ", produtos[contador].preco:1:2)
         escrevaL("Estoque : ", produtos[contador].estoque:1)
         escrevaL()
      fimPara
   fimSe
fimProcedimento

procedimento consultarEstoque ()
var
   novoProduto : t_Produto
   posProduto : inteiro
   p: inteiro
inicio
   se  (não vetorVazio())então
      escreval("Informe o nome do produto que gostaria de consultar o estoque")
      leia(novoProduto.nome)
      se  produtoCadastrado(novoProduto.nome)então
         posProduto <- buscaPosicaoProduto(novoProduto.nome)
         se (posProduto > 0) então
            escreval(" O estoque de ", produtos[posProduto].nome, " é ", produtos[posProduto].estoque:1)
         fimSe
      fimse
   fimSe
fimProcedimento

procedimento atualizarEstoque ()
var
   novoProduto: t_Produto
   opcao : caractere
   quantidade: inteiro
   posProduto : inteiro
inicio
   se  (não vetorVazio())então
      escreval("Informe o nome do produto que gostaria de atualizar o estoque")
      leia(novoProduto.nome)
      se  buscaPosicaoProduto(novoProduto.nome)> 0 então
         escreval ("[A] - adicionar")
         escreval ("[R] - retirar")
         leia(opcao)
         opcao <- maiusc(opcao)
         se opcao = "A" então
            escreval("Quanto gostaria de adicionar?")
            leia(quantidade)
            posProduto <- buscaPosicaoProduto(novoProduto.nome)
            produtos[posProduto].estoque <- produtos[posProduto].estoque+quantidade
            escreval("O novo estoque de ", novoProduto.nome, " é ", produtos[posProduto].estoque:1)
         senao
            se opcao = "R" então
               escreval("Quanto gostaria de retirar?")
               leia(quantidade)
               posProduto <- buscaPosicaoProduto(novoProduto.nome)
               produtos[posProduto].estoque <- produtos[posProduto].estoque-quantidade
               escreval("O novo estoque de ", novoProduto.nome, " é ", produtos[posProduto].estoque:1)
            fimse
         fimSe
      fimSE
   fimSe
fimProcedimento


funcao produtoCadastrado(nome:caractere): logico
var
   contador: inteiro
   resultado : logico
inicio
   resultado <- FALSO
   para contador <- 1 ate qtdProdutos faca
      se nome = produtos[contador].nome então
         resultado <- VERDADEIRO
      senao
         escreval("Produto não cadastrado")
         resultado <- FALSO
      fimSe
   fimPara
   retorne resultado
fimFuncao

var
   produtos : vetor [1..QTD_MAX_PRODUTOS] de t_Produto
   opcao, qtdProdutos : inteiro

inicio

   qtdProdutos <- 0
   repita
      escrevaL("[1]- Cadastrar produto")
      escrevaL("[2]- Consultar produto")
      escrevaL("[3]- Atualizar estoque")
      escrevaL("[4]- Listar produtos")

      escrevaL("Escolha uma opcao")
      leia (opcao)

      escolha (opcao)
      caso 1
         cadastrarProduto()
      caso 2
         consultarEstoque()
      caso 3
         atualizarEstoque()
      caso 4
         listarProdutos()
      fimEscolha
   ate (opcao = 0)

fimAlgoritmo

Simon Viegas · 11 de novembro de 2023

Em 09/11/2023 às 15:37, Eli Almeidaa disse:

Não consegui pensar em uma lógica para usar os valores verdadeiro e falso, como você já vinha fazendo para retornar um valor lógico para essa função.

Do que entendi, você está usando os valores lógicos.

Em 09/11/2023 às 15:37, Eli Almeidaa disse:
      se (produtoCadastrado(novoProduto.nome)) então

      fimse

O se está utilizando o valor retornado pela função.

Em 09/11/2023 às 15:37, Eli Almeidaa disse:

Fiz assim, não sei se está correto:

Pra mim ficou correto, sim. Tá muito bom!

Para exemplificar uma nova possível simplificação:

DE:

Em 09/11/2023 às 15:37, Eli Almeidaa disse:

funcao produtoExiste (nome:caractere) : logico
var
   contador : inteiro
   existe : logico
inicio
   existe <- FALSO

   para contador <- 1 ate qtdProdutos faca
      se (produtos[contador].nome = nome) então
         escrevaL("Já existe um produto com o nome '", nome, "' no cadastro!")
         existe <- VERDADEIRO
         interrompa()
      fimSe
   fimPara

   retorne existe
fimFuncao

funcao buscaPosicaoProduto(nome:caractere):inteiro
var
   resultado : inteiro
   contador : inteiro
inicio
   resultado <- 0

   para contador <- 1 ate qtdProdutos faca
      se (nome = produtos[contador].nome) então
         resultado <- contador
         interrompa()
      fimse
   fimPara

   retorne resultado
fimFuncao

Observe que um código é bem parecido com o outro... daí poderia remover esse "código repetido", deixando a estrutura de busca em apenas um local.

PARA:

funcao produtoExiste (nome:caractere) : logico
var
   resultado : logico
inicio
   resultado <- FALSO

   se (buscaPosicaoProduto(nome) > 0) então
      escrevaL("Já existe um produto com o nome '", nome, "' no cadastro!")
      existe <- VERDADEIRO
   fimSe

   retorne resultado
fimFuncao

funcao buscaPosicaoProduto(nome:caractere) : inteiro
var
   resultado : inteiro
   contador : inteiro
inicio
   resultado <- 0

   para contador <- 1 ate qtdProdutos faca
      se (nome = produtos[contador].nome) então
         resultado <- contador
         interrompa()
      fimse
   fimPara

   retorne resultado
fimFuncao

Ou seja: a busca pela posição já indica se existe ou não... assim reaproveita o que já tem, em vez de "duplicar o código".

O produtoCadastrado() pode seguir a mesma lógica.

Eli Almeida · 16 de novembro de 2023

@Simon Viegas, ajustei o código conforme você mostrou.

Código completo:

Algoritmo "Gerenciamento de Produtos v0.3"

// Disciplina  :
// Professor   :
// Autor(a)    : Eli Almeidaa
// Data atual  : 18/10/2023
// ENUNCIADO:

const
   QTD_MAX_PRODUTOS = 2

tipo
   t_Produto = registro
      nome : caractere
      preco : real
      estoque : inteiro
   fimRegistro

funcao vetorVazio() : logico
var
   retorno : logico
inicio
   retorno <- FALSO
   se (qtdProdutos <= 0) então
      escrevaL("Não há produtos cadastrados")
      retorno <- VERDADEIRO
   senao
      retorno <- FALSO
   fimSe

   retorne retorno
fimFuncao

funcao vetorCheio() : logico
var
   retorno : logico
inicio
   retorno <- FALSO

   se (qtdProdutos >= QTD_MAX_PRODUTOS) então
      escrevaL("Não há mais espaço no vetor para cadastro de novos produtos")
      retorno <- VERDADEIRO
   fimSe

   retorne retorno
fimFuncao


funcao produtoExiste (nome:caractere) : logico
var
   contador : inteiro
   existe : logico
inicio
   existe <- FALSO

   se (buscaPosicaoProduto(nome) > 0) então
      escrevaL("Já existe um produto com o nome '", nome, "' no cadastro!")
      existe <- VERDADEIRO
      interrompa()
   fimSe
   retorne existe
fimFuncao

funcao buscaPosicaoProduto(nome:caractere):inteiro
var
   resultado : inteiro
   contador : inteiro
inicio
   resultado <- 0

   para contador <- 1 ate qtdProdutos faca
      se (nome = produtos[contador].nome) então
         resultado <- contador
         interrompa()
      fimse
   fimPara

   retorne resultado
fimFuncao

procedimento cadastrarProduto()
var
   novoProduto : t_Produto
   produtoJaExiste : logico
inicio
   se (não vetorCheio()) então
      repita
         produtoJaExiste <- FALSO
         escrevaL("Informe o nome do produto")
         leia(novoProduto.nome)
         produtoJaExiste <- produtoExiste(novoProduto.nome)
         se (não produtoJaExiste) então
            escrevaL("Informe o preço do produto")
            leia(novoProduto.preco)
            escrevaL("Informe o estoque do produto")
            leia(novoProduto.estoque)
            qtdProdutos <- qtdProdutos+1
            produtos[qtdProdutos] <- novoProduto
            escrevaL("Produto cadastrado com sucesso")
         fimSe
      ate (não produtoJaExiste)
   fimse
fimProcedimento

procedimento listarProdutos()
var
   contador : inteiro
inicio
   se(não vetorVazio ()) então
      escrevaL("Produtos cadastrados :")
      para contador <- 1 ate qtdProdutos faca
         escrevaL("Nome    : ", produtos[contador].nome)
         escrevaL("Preço   : R$ ", produtos[contador].preco:1:2)
         escrevaL("Estoque : ", produtos[contador].estoque:1)
         escrevaL()
      fimPara
   fimSe
fimProcedimento

procedimento consultarEstoque ()
var
   novoProduto : t_Produto
   posProduto : inteiro
   p: inteiro
inicio
   se  (não vetorVazio())então
      escreval("Informe o nome do produto que gostaria de consultar o estoque")
      leia(novoProduto.nome)
      se  produtoCadastrado(novoProduto.nome)então
         posProduto <- buscaPosicaoProduto(novoProduto.nome)
         se (posProduto > 0) então
            escreval(" O estoque de ", produtos[posProduto].nome, " é ", produtos[posProduto].estoque:1)
         fimSe
      fimse
   fimSe
fimProcedimento

procedimento atualizarEstoque ()
var
   novoProduto: t_Produto
   opcao : caractere
   quantidade: inteiro
   posProduto : inteiro
inicio
   se  (não vetorVazio())então
      escreval("Informe o nome do produto que gostaria de atualizar o estoque")
      leia(novoProduto.nome)
      se  buscaPosicaoProduto(novoProduto.nome)> 0 então
         escreval ("[A] - adicionar")
         escreval ("[R] - retirar")
         leia(opcao)
         opcao <- maiusc(opcao)
         se opcao = "A" então
            escreval("Quanto gostaria de adicionar?")
            leia(quantidade)
            posProduto <- buscaPosicaoProduto(novoProduto.nome)
            produtos[posProduto].estoque <- produtos[posProduto].estoque+quantidade
            escreval("O novo estoque de ", novoProduto.nome, " é ", produtos[posProduto].estoque:1)
         senao
            se opcao = "R" então
               escreval("Quanto gostaria de retirar?")
               leia(quantidade)
               posProduto <- buscaPosicaoProduto(novoProduto.nome)
               produtos[posProduto].estoque <- produtos[posProduto].estoque-quantidade
               escreval("O novo estoque de ", novoProduto.nome, " é ", produtos[posProduto].estoque:1)
            fimse
         fimSe
      fimSE
   fimSe
fimProcedimento


funcao produtoCadastrado(nome:caractere): logico
var
   contador: inteiro
   resultado : logico
inicio
   resultado <- FALSO
   se (buscaPosicaoProduto(nome) > 0) então
      resultado <- VERDADEIRO
   senao
      escreval("Produto não cadastrado")
      resultado <- FALSO
   fimSe
   retorne resultado
fimFuncao

var
   produtos : vetor [1..QTD_MAX_PRODUTOS] de t_Produto
   opcao, qtdProdutos : inteiro

inicio

   qtdProdutos <- 0
   repita
      escrevaL("[1]- Cadastrar produto")
      escrevaL("[2]- Consultar produto")
      escrevaL("[3]- Atualizar estoque")
      escrevaL("[4]- Listar produtos")

      escrevaL("Escolha uma opcao")
      leia (opcao)

      escolha (opcao)
      caso 1
         cadastrarProduto()
      caso 2
         consultarEstoque()
      caso 3
         atualizarEstoque()
      caso 4
         listarProdutos()
      fimEscolha
   ate (opcao = 0)

fimAlgoritmo

Simon Viegas · 17 de novembro de 2023

Show! Só um detalhe: ao informar um nome de produto inexistente, o programa "não faz nada".

Poderia dar uma arrumada nisso.

Eli Almeida · 22 de novembro de 2023

@Simon Viegas, usei a mesma lógica que já tinha no procedimento consultar estoque para atualizar o estoque e consertar esse erro, ao informar um nome de produto inexistente.

Algoritmo "Gerenciamento de Produtos v0.3"

// Disciplina  :
// Professor   :
// Autor(a)    : Eli Almeidaa
// Data atual  : 18/10/2023
// ENUNCIADO:

const
   QTD_MAX_PRODUTOS = 2

tipo
   t_Produto = registro
      nome : caractere
      preco : real
      estoque : inteiro
   fimRegistro

funcao vetorVazio() : logico
var
   retorno : logico
inicio
   retorno <- FALSO
   se (qtdProdutos <= 0) então
      escrevaL("Não há produtos cadastrados")
      retorno <- VERDADEIRO
   senao
      retorno <- FALSO
   fimSe

   retorne retorno
fimFuncao

funcao vetorCheio() : logico
var
   retorno : logico
inicio
   retorno <- FALSO

   se (qtdProdutos >= QTD_MAX_PRODUTOS) então
      escrevaL("Não há mais espaço no vetor para cadastro de novos produtos")
      retorno <- VERDADEIRO
   fimSe

   retorne retorno
fimFuncao


funcao produtoExiste (nome:caractere) : logico
var
   contador : inteiro
   existe : logico
inicio
   existe <- FALSO

   se (buscaPosicaoProduto(nome) > 0) então
      escrevaL("Já existe um produto com o nome '", nome, "' no cadastro!")
      existe <- VERDADEIRO
      interrompa()
   fimSe
   retorne existe
fimFuncao

funcao buscaPosicaoProduto(nome:caractere):inteiro
var
   resultado : inteiro
   contador : inteiro
inicio
   resultado <- 0

   para contador <- 1 ate qtdProdutos faca
      se (nome = produtos[contador].nome) então
         resultado <- contador
         interrompa()
      fimse
   fimPara

   retorne resultado
fimFuncao

procedimento cadastrarProduto()
var
   novoProduto : t_Produto
   produtoJaExiste : logico
inicio
   se (não vetorCheio()) então
      repita
         produtoJaExiste <- FALSO
         escrevaL("Informe o nome do produto")
         leia(novoProduto.nome)
         produtoJaExiste <- produtoExiste(novoProduto.nome)
         se (não produtoJaExiste) então
            escrevaL("Informe o preço do produto")
            leia(novoProduto.preco)
            escrevaL("Informe o estoque do produto")
            leia(novoProduto.estoque)
            qtdProdutos <- qtdProdutos+1
            produtos[qtdProdutos] <- novoProduto
            escrevaL("Produto cadastrado com sucesso")
         fimSe
      ate (não produtoJaExiste)
   fimse
fimProcedimento

procedimento listarProdutos()
var
   contador : inteiro
inicio
   se(não vetorVazio ()) então
      escrevaL("Produtos cadastrados :")
      para contador <- 1 ate qtdProdutos faca
         escrevaL("Nome    : ", produtos[contador].nome)
         escrevaL("Preço   : R$ ", produtos[contador].preco:1:2)
         escrevaL("Estoque : ", produtos[contador].estoque:1)
         escrevaL()
      fimPara
   fimSe
fimProcedimento

procedimento consultarEstoque ()
var
   novoProduto : t_Produto
   posProduto : inteiro
   p: inteiro
inicio
   se  (não vetorVazio())então
      escreval("Informe o nome do produto que gostaria de consultar o estoque")
      leia(novoProduto.nome)
      se produtoCadastrado(novoProduto.nome)então
         posProduto <- buscaPosicaoProduto(novoProduto.nome)
         se (posProduto > 0) então
            escreval(" O estoque de ", produtos[posProduto].nome, " é ", produtos[posProduto].estoque:1)
         fimSe
      fimse
   fimSe
fimProcedimento

procedimento atualizarEstoque ()
var
   novoProduto: t_Produto
   opcao : caractere
   quantidade: inteiro
   posProduto : inteiro
inicio
   se  (não vetorVazio())então
      escreval("Informe o nome do produto que gostaria de atualizar o estoque")
      leia(novoProduto.nome)
      se produtoCadastrado(novoProduto.nome)então
         se  buscaPosicaoProduto(novoProduto.nome)> 0 então
            escreval ("[A] - adicionar")
            escreval ("[R] - retirar")
            leia(opcao)
            opcao <- maiusc(opcao)
            se opcao = "A" então
               escreval("Quanto gostaria de adicionar?")
               leia(quantidade)
               posProduto <- buscaPosicaoProduto(novoProduto.nome)
               produtos[posProduto].estoque <- produtos[posProduto].estoque+quantidade
               escreval("O novo estoque de ", novoProduto.nome, " é ", produtos[posProduto].estoque:1)
            senao
               se opcao = "R" então
                  escreval("Quanto gostaria de retirar?")
                  leia(quantidade)
                  posProduto <- buscaPosicaoProduto(novoProduto.nome)
                  produtos[posProduto].estoque <- produtos[posProduto].estoque-quantidade
                  escreval("O novo estoque de ", novoProduto.nome, " é ", produtos[posProduto].estoque:1)
               fimse
            fimSe
         fimSE
      fimSe
   fimse
fimProcedimento


funcao produtoCadastrado(nome:caractere): logico
var
   contador: inteiro
   resultado : logico
inicio
   resultado <- FALSO
   se (buscaPosicaoProduto(nome) > 0) então
      resultado <- VERDADEIRO
   senao
      escreval("Produto não cadastrado")
      resultado <- FALSO
   fimSe
   retorne resultado
fimFuncao

var
   produtos : vetor [1..QTD_MAX_PRODUTOS] de t_Produto
   opcao, qtdProdutos : inteiro

inicio

   qtdProdutos <- 0
   repita
      escrevaL("[1]- Cadastrar produto")
      escrevaL("[2]- Consultar produto")
      escrevaL("[3]- Atualizar estoque")
      escrevaL("[4]- Listar produtos")

      escrevaL("Escolha uma opcao")
      leia (opcao)

      escolha (opcao)
      caso 1
         cadastrarProduto()
      caso 2
         consultarEstoque()
      caso 3
         atualizarEstoque()
      caso 4
         listarProdutos()
      fimEscolha
   ate (opcao = 0)

fimAlgoritmo