VisualG Código usando vetores e sub-rotinas (Procedimentos ou Funções) no Visualg

[Gust Alves]

Boa tarde, pessoal! Estava fazendo umas questões aqui no visualg e tive um impasse. A questão é a seguinte: Para demonstrar o uso de sub-rotina com passagem de parâmetro, considere a leitura de 10 valores em um vetor e os coloque em ordem crescente. A ordenação deve ser executada por uma sub-rotina apropriada para este fim.

Bom, até a parte de fazer a leitura e ordenação do vetor consigo normalmente, mas quando pede para ordenar com uma sub-rotina não estou conseguindo resolver, então queria pedir ajuda para resolver meu código.

Código:
 

Algoritmo "EXE4SUBROTINAS"
Var
   Vet: Vetor[1..10] de Inteiro
   L, A, Aux: Inteiro
Inicio
      Para L := 1 ate 10 Faca
           Escreva("Digite um numero: ")
           Leia(Vet[L])
      FimPara
      Para L de 1 ate 9 Faca
           Para A de 1 ate 10 - L Faca
                Se (Vet[A] > Vet[A + 1]) então
                   Aux := Vet[A]
                   Vet[A] := Vet[A + 1]
                   Vet[A + 1] := aux
                FimSe
           FimPara
      FimPara
      Para L := 1 ate 10 Faca
           Escreva(Vet[L])
      FimPara
Fimalgoritmo

 

[devair1010]

@Gustavo Alves7    conforme explicado nesse link :

https://pt.stackoverflow.com/questions/389799/É-possível-passar-um-vetor-como-parâmetro-no-visualg

o vetor no visualG 3.0.6.5 é um tipo de estruturado e não pode ser passado como parâmetros ,  porém você pode criar uma função ,  que serve de subrotina  sem enviar o vetor pois no visualG as variáveis usadas no bloco principal do compilador ,  que é tudo que esteja entre o "Inicio e o Fimalgoritmo" , precisam ser criadas lá no início do código na seção "Var" e portanto são globais e assim podem ser acessadas em qualquer local do código , e a subrotina / função  fará a ordenação dos números e ao retornar  poderão ser escritos  .

e seu código ficaria assim :

Algoritmo "EXE4SUBROTINAS_02"
Var
   Vet            : Vetor[1..10] de Inteiro
   L, A, Aux, ret : Inteiro

funcao sub_rotina(tam_vet : inteiro):inteiro
Var
  A,L : inteiro
Inicio
   Para    L de 1 ate 9      Faca
      Para A de 1 ate 10 - L Faca
         Se Vet[A    ] >  Vet[A + 1] então
            Aux        := Vet[A    ]
            Vet[A    ] := Vet[A + 1]
            Vet[A + 1] := aux
         FimSe
      FimPara
   FimPara
   retorne tam_vet
Fimfuncao
Inicio
   Para L := 1 ate 10 Faca
      Escreva("Digite um numero: ")
      Leia(Vet[L])
   FimPara
   // passagem de parâmetro dos Tipos : Logico  Real  inteiro ou caractere
   
   ret <- sub_rotina(10) // enviou o num 10 como parAmetro para a FunCAo
     
   {
   // essa ordenaCAo será na funCAo
   Para L de 1 ate 9 Faca
      Para A de 1 ate 10 - L Faca
         Se (Vet[A] > Vet[A + 1]) então
            Aux := Vet[A]
            Vet[A] := Vet[A + 1]
            Vet[A + 1] := aux
         FimSe
      FimPara
   FimPara
   }
   // Aqui escreve os nUmeros que estarAo ordenados
   Escreval("")
   Escreval("Valor retornado da Função ",ret) // ret Eh o valor retornado
   Escreval("")
   Para L := 1 ate 10 Faca
      Escreva(Vet[L])
   FimPara
   Escreval("")
Fimalgoritmo

 

[Simon Viegas]

13 horas atrás, devair1010 disse:

funcao sub_rotina(tam_vet : inteiro):inteiro
Var
  A,L : inteiro
Inicio
   Para    L de 1 ate 9      Faca
      Para A de 1 ate 10 - L Faca
         Se Vet[A    ] >  Vet[A + 1] então
            Aux        := Vet[A    ]
            Vet[A    ] := Vet[A + 1]
            Vet[A + 1] := aux
         FimSe
      FimPara
   FimPara
   retorne tam_vet
Fimfuncao

 

Está recebendo o parâmetro, mas não está usando na ordenação... Poderia ficar com algo assim:

   Para    L de 1 ate tam_vet     Faca
      Para A de 1 ate tam_vet - L Faca

 

Daí o retorno também não seria necessário, pois está retornando o próprio valor original que foi recebido. Se não me engano isso seria uma Tautologia. Portanto, usaria um procedimento (que não tem retorno na próprio método), em detrimento de usar uma função (que é basicamente um procedimento que tem o tal retorno). 

 

PS: em linguagens mais modernas/comuns, não existe diferenciação entre procedimento e função, tudo é função... daí, as funções podem ou não retornar algo... quando não precisa retornar, comumente é definido com o "retorno void" (que significa vazio), ou seja, se o VisualG tivesse esse conceito, um procedimento seria algo assim:

 

funcao xpto () : vazio
inicio

fimFuncao

 

 

 

Alguns pontos:

19 horas atrás, Gustavo Alves7 disse:

L, A, Aux: Inteiro

Por que especificamente "L" e "A"? Tem alguma correlação com algo?

 

Convencionalmente utilizam-se "i" e "j" como variáveis auxiliares para as iterações do para.

i, j, aux : inteiro

 

Como sugerível acima, as variáveis e comando também são comumentes iniciadas em minúsculo. Dá uma pesquisada sobre camelCase... (Obs.: isso não é obrigatório, estaria relacionado mais a uma tentativa de seguir um suposto padrão geral.

 

Exemplo de código sem sub-rotina:

algoritmo "EXE4SUBROTINAS"
//Para demonstrar o uso de sub-rotina com passagem de parâmetro, considere a
//leitura de 10 valores em um vetor e os coloque em ordem crescente. A
//ordenação deve ser executada por uma sub-rotina apropriada para este fim.

var
   vet : vetor [1..10] de inteiro
   i, j, aux : inteiro

inicio
   para i de 1 ate 10 faca
      escreva ("Digite um numero: ")
      leia(vet[i]:3)
   fimPara

   escreva ("Vetor original :")

   para i <- 1 ate 10 Faca
      escreva (vet[i])
   fimPara

   escrevaL("")
   
   para i de 1 ate 9 Faca
      para j de 1 ate 10-i faca
         se (vet[j] > vet[j+1]) então
            aux <- vet[j]
            vet[j] <- vet[j+1]
            vet[j+1] <- aux
         fimSe
      fimPara
   fimPara

   escreva ("Vetor ordenado :")

   para i <- 1 ate 10 faca
      escreva (vet[i]:3)
   fimPara
fimAlgoritmo

Para facilita os testes, pode deixar essa opção marcada:

 

Ai o próprio VisualG preenche com valores aleatório. Resultado ao pressionar F9:

 

 

19 horas atrás, Gustavo Alves7 disse:

Para demonstrar o uso de sub-rotina com passagem de parâmetro [...]

 

Como já citado, por uma limitação técnica (o criador/desenvolvedor) simplesmente não implementou o recurso que possibilite passar vetores por parâmetro em procedimentos ou funções. É isso! O Pascal, "pai do VisualG", permite! Quem sabe vem numa próxima versão?

 

Daí... meio que o enunciado fica vago... Pois o vetor, necessariamente, terá que ser "passado" via variável global... e o tamanho do vetor também já é conhecido e fixo... já que está no próprio enunciado:

19 horas atrás, Gustavo Alves7 disse:

considere a leitura de 10 valores em um vetor

 

 

19 horas atrás, Gustavo Alves7 disse:

A ordenação deve ser executada por uma sub-rotina apropriada para este fim

 

O código poderia ficar com algo assim:

 

O esqueleto do procedimento:

procedimento bubbleSort ()
inicio

fimProcedimento

https://pt.wikipedia.org/wiki/Bubble_sort

 

Aí só joga o conteúdo dentro:

   para i de 1 ate 9 Faca
      para j de 1 ate 10-i faca
         se (vet[j] > vet[j+1]) então
            aux <- vet[j]
            vet[j] <- vet[j+1]
            vet[j+1] <- aux
         fimSe
      fimPara
   fimPara

 

 

 

ADENDO IMPORTANTE:

Como boa prática, é interessante que "tudo que método use, ou venha por parâmetro, ou seja declarado dentro do método", ou seja, o vetor e o tamanho do vetor deveriam* vir por parâmetro (o primeiro o VisualG não permite, o segundo já foi proposto que é fixo), e as variáveis utilizadas no laços de repetições, declaradas dentro do método (criação de variáveis locais, que se separam das variáveis locais). Veja:

 

procedimento bubbleSort ()
var
   i, j, aux : inteiro
inicio
   para i de 1 ate 9 Faca
      para j de 1 ate 10-i faca
         se (vet[j] > vet[j+1]) então
            aux <- vet[j]
            vet[j] <- vet[j+1]
            vet[j+1] <- aux
         fimSe
      fimPara
   fimPara
fimProcedimento

 

 

Daí só invocar o método onde precisa:

   ...
      escreva (vet[i]:3)
   fimPara

   escrevaL("")

   bubbleSort()

   escreva ("Vetor ordenado :")

   para i <- 1 ate 10 faca
   ...

 

Olha como é interessante, uma sub-rotina seria basicamente um bloco de comandos em que se deu um nome... aí só invocar! Na prática, o VisualG vai "pular" para o trecho de código e ir executando linha a linha da mesma forma que se tivesse no corpo principal do código e depois volta para próxima linha depois de onde foi invocado. Como se fosse um "subprograma". O programa principal fica aguardando a sub-rotina terminar.

 

Código completo:

Spoiler

algoritmo "EXE4SUBROTINAS"
//Para demonstrar o uso de sub-rotina com passagem de parâmetro, considere a
//leitura de 10 valores em um vetor e os coloque em ordem crescente. A
//ordenação deve ser executada por uma sub-rotina apropriada para este fim.


procedimento bubbleSort ()
var
   i, j, aux : inteiro
inicio
   para i de 1 ate 9 Faca
      para j de 1 ate 10-i faca
         se (vet[j] > vet[j+1]) então
            aux <- vet[j]
            vet[j] <- vet[j+1]
            vet[j+1] <- aux
         fimSe
      fimPara
   fimPara
fimProcedimento

var
   vet : vetor [1..10] de inteiro
   i, j, aux : inteiro

inicio
   para i de 1 ate 10 faca
      escreva("Digite um numero: ")
      leia(vet[i])
   fimPara

   escreva ("Vetor original :")

   para i <- 1 ate 10 Faca
      escreva (vet[i]:3)
   fimPara

   escrevaL("")

   bubbleSort()

   escreva ("Vetor ordenado :")

   para i <- 1 ate 10 Faca
      escreva (vet[i]:3)
   fimPara
fimAlgoritmo

  

 

Aí, como parâmetros são necessário, poderia seguir a sugestão do @devair1010, ficaria algo assim:

procedimento bubbleSort (tam : inteiro)
var
   i, j, aux : inteiro
inicio
   para i de 1 ate tam-1 Faca
      para j de 1 ate tam-i faca
         se (vet[j] > vet[j+1]) então
            aux <- vet[j]
            vet[j] <- vet[j+1]
            vet[j+1] <- aux
         fimSe
      fimPara
   fimPara
fimProcedimento

 

Chama o método passando o parâmetro necessário.

   ...
   escrevaL("")

   bubbleSort(10)

   escreva ("Vetor ordenado :")
   ...

 

Ou, ainda aprimorar o Bubble Sort(), criando um método específico para efetuar as trocas de posições:

algoritmo "EXE4SUBROTINAS"
//Para demonstrar o uso de sub-rotina com passagem de parâmetro, considere a
//leitura de 10 valores em um vetor e os coloque em ordem crescente. A
//ordenação deve ser executada por uma sub-rotina apropriada para este fim.

procedimento troca(var a, b : inteiro)
var
   aux : inteiro
inicio
   aux <- a
   a <- b
   b <- aux
fimProcedimento

procedimento bubbleSort ()
var
   i, j : inteiro
inicio
   para i de 1 ate 10-1 Faca
      para j de 1 ate 10-i faca
         se (vet[j] > vet[j+1]) então
            troca(vet[j], vet[j+1])
         fimSe
      fimPara
   fimPara
fimProcedimento

var
   vet : vetor [1..10] de inteiro
   i, j, aux : inteiro

inicio
   para i de 1 ate 10 faca
      escreva("Digite um numero: ")
      leia(vet[i])
   fimPara

   escreva ("Vetor original :")

   para i <- 1 ate 10 Faca
      escreva (vet[i]:3)
   fimPara

   escrevaL("")

   bubbleSort()

   escreva ("Vetor ordenado :")

   para i <- 1 ate 10 Faca
      escreva (vet[i]:3)
   fimPara
fimAlgoritmo

 

Ou seja: o procedimento troca() já satisfaria a exigência do enunciado ("uso de sub-rotina com passagem de parâmetro"). Mas tanto faz também deixar o método de ordenação também recebendo o parâmetro com o tamanho do vetor.

 

Ah! se o VisualG aceitasse vetores por parâmetro, a assinatura seria algo assim:

 

procedimento bubbleSort (var vet:vetor)

Ou:

procedimento bubbleSort (var vet:vetor; tam:inteiro)

Lembrando que isso NÃO FUNCIONA... pois ainda não foi implementando no VisualG. Já no Pascal, sim!... (não exatamente assim, mas funciona )

 

PS: esse var determina que seria uma passagem de parâmetro do referência, ou seja, a variável local do método aponta diretamente para própria variável da qual foi passado o parâmetro, assim, tudo que for alterado dentro do método, será refletido na variável original... Funciona como um "ponteiro de memória". Já sem o var, o VisualG apenas "copia" o valor original e joga na variável local. Ao sair, a variável original fica intacta.

 

 

POSSÍVEL DÚVIDAS:

Oxente, por que declarou duas vezes as variáveis i e j? E pior, por que o VisualG não acusou que a variável foi "declarada mais de uma vez". Vide exemplo:

 

 

Resposta: as variáveis i e j foram declaradas "novamente" pois eventualmente o escopo do método precisa dessas variáveis, e como foi exposto no "ADENDO IMPORTANTE" mais acima, o objetivo é "isolar" o método do programa principal, ou seja, mesmo que seja modificado o laço de repetição no programa principal, o método não será comprometido, pois "tudo dentro do método ou veio de fora ou foi criado dentro do método"...

Por fim, foi utilizado também as mesmas letras, pois o VisualG permite. Poderia ser letras diferentes. Só se atente que são variáveis distintas! Tem a mesma nomenclatura, mas são de escopos diferentes. Veja:

 

Cada par de variável não tem nada a ver com o outro. Se não declarasse as variáveis locais, a sub-rotina iria utilizar a variáveis globais...

 

A magia vem aí... ao implementar uma método, você não precisa se preocupar se já existe uma variável com a mesma nomenclatura fora, nem muito menos vai se preocupar se está alterando um valor que não deveria... Por isso a importância do "isolamento". Isso vai ficar mais claro e medida que for implementando programas maiores... imagine a trabalheira que dá ficar "cuidado de cada variável". 

 

[Gust Alves]

@devair1010 @Simon Viegas Perdão pela demora, obrigado pela ajuda pessoal!