Conhecendo Procedimentos e Funções
Durante o desenvolvimento de um programa é comum surgirem situações onde, constantemente, temos que repetir algumas instruções. Já vimos que quando essas instruções repetidas são sequências, podemos fazer uso de laços de repetição.
Porém, existem situações que não necessariamente envolvem o uso de laços. Imagine, por exemplo, que por alguma razão você precisa em vários momentos do seu programa calcular a média de dois números ou então, precisa constantemente mostrar uma mensagem para o usuário na tela.
Para evitar uma digitação repetitiva de forma desnecessária as linguagens de programação e o Portugol fazem uso dos Procedimentos e das Funções. Ambos são blocos de instruções previamente armazenados no código que possuem um nome e, quando são necessários no programa, basta chama-los pelos nomes que os identificam.
Veja abaixo um exemplo mostrando a criação de um procedimento para criar um cabeçalho de tela para um programa:
- programa {
- funcao inicio() {
- cabecalho()
- }
- funcao cabecalho(){
- limpa()
- escreva("****************************************\n")
- escreva("**** Programa para Cálculo de Média ****\n")
- escreva("****************************************\n")
- }
- }
Na linha 3 eu estou chamando o meu procedimento através da instrução cabecalho() e essa instrução faz ele executar tudo entre as linhas 5 e 10. Temos, portanto, uma sub-rotina sendo chamada pela rotina principal.
A novidade aqui é a função limpa() usada pelo Portugol para apagar tudo que está na tela. O que não significa que todo o procedimento precisa limpar a tela.
Repare que temos dois blocos de abre e fecha chaves {}no nosso programa. Um da linha 2 a 4 para a função inicio() que já conhecemos e outro, da linha 5 e 10 para o Procedimento cabecalho().
Diferença entre Procedimentos e Funções
Para o Portugol, o processo de criação de Procedimentos e Funções, basicamente utiliza a mesma instrução funcao, porém existe uma diferença técnica que faz com que um seja chamado de Procedimento e o outro de Função
No exemplo que eu comentei acima, se eu preciso apenas mostrar uma mensagem para o usuário na tela, sem precisar devolver para o programa nenhum valor ou resultado de cálculo, então eu estou diante de um Procedimento, que não retorna nada ao programa.
Já o cálculo da média vai devolver para o usuário o resultado do cálculo. Sendo assim, eu estou diante de uma Função, pois ela retorna um valor para o programa. Sendo assim, eu vou precisar informar que tipo de dados ela estará devolvendo.
Geralmente ao chamar um procedimento no código, teremos uma instrução simples como nome_do_procedimento(). Já nas chamadas das funções, como ela retorna um valor teremos a presença de uma variável para guardar o retorno ou ela será inserida dentro dos parenteses de outra função.
Exemplos de chamadas para funções denominadas imposto e desconto:
escreva(desconto())
O que são parâmetros de uma função ou procedimento
Muitas vezes, eu vou precisar passar algumas informações para o Procedimento ou para a Função serem executados. Por exemplo, para calcular a média de dois números, a minha função vai precisar como parâmetro esses dois números para o cálculo.
Esses parâmetros são passados para a função ou procedimento dentro de parenteses. Por exemplo, se eu quero calcular a média de 5 e 7, poderia dar a instrução media(5,7) se o parâmetros forem definidos como inteiros ou media(5.0,7.0) se os parâmetros forem do tipo real. Eu preciso informar os tipos de dados dos parâmetros nas instruções de criação da função ou do procedimento.
Estrutura genérica de um procedimento chamado exemplo com dois parâmetros:
}
Estrutura genérica de uma função exemplo com dois parâmetros:
}
- programa {
- funcao inicio() {
- real resultado
- cabecalho()
- resultado=media(10.0,20.0)
- escreva("média igual a "+resultado)
- }
- funcao cabecalho(){
- limpa()
- escreva("****************************************\n")
- escreva("**** Programa para Cálculo de Média ****\n")
- escreva("****************************************\n")
- }
- funcao real media(real numero1, real numero2){
- escreva("Calculando a média de "+numero1+" e "+numero2+"\n")
- retorne (numero1+numero2)/2
- }
- }
Repare que nesse exemplo eu criei uma variável na linha 3 que chamei de resultado para armazenar o retorno da função media, conforme o que está na linha 5. Repare também que nessa linha eu estou passando os dois números para o cálculo da média como parâmetros. Eles estão com o ponto decimal porque são do tipo real.
O conjunto de instruções que formam a função média estão entre as linhas 14 e 17. A instrução real antes do nome media informa que o retorno da função será do tipo real. Dentro dos parenteses eu estou definindo que vou precisar de dois números do tipo real como parâmetros. A linha 16 informa o que eu estou retornando da função, que no caso é a média.
Vantagens do uso de Procedimentos e Funções
Ao dividir o código em blocos de procedimentos e funções eu estou organizando melhor a codificação praticando a chamada modularização do código que é criar módulos independentes e interconectados.
Esse processo facilita a manutenção do programa nas operações de correção de erros e nas modificações durante o desenvolvimento. Além disso permite agilizar a implementação de novas funcionalidades, também facilita a divisão de trabalhos em equipes, deixa o código mais legível e reutilizável.
Reorganizando o programa da média
No exemplo abaixo, pegamos o último dos códigos do programa de média já vistos e reorganizamos as instruções em procedimentos e funções, além de implementar novos recursos. As cores indicam a divisão em blocos. Repare que eu utilizei uma variável lógica chamada infinito para armazenar o valor verdadeiro e com ela controlar o laço enquanto.
- programa {
- funcao inicio () {
- principal()
- }
- funcao principal(){
- logico infinito=verdadeiro
- inteiro contador=0
- enquanto(infinito){
- cabecalho()
- contador=contador+1
- infinito=entrada()
- }
- escreva("Total de alunos: "+contador)
- }
- funcao cabecalho(){
- limpa()
- escreva("****************************************\n")
- escreva("**** Programa para Cálculo de Média ****\n")
- escreva("****************************************\n")
- }
- funcao logico entrada(){
- caracter resposta
- inteiro frequencia, contador2
- cadeia nome
- real nota,somatoria,MediaFinal
- escreva("\nDigite a nome: ")
- leia(nome)
- somatoria=0.0
- para(contador2=1;contador2<=3;contador2++){
- escreva("Digite a nota"+contador2+": ")
- leia(nota)
- somatoria=somatoria+nota
- MediaFinal=somatoria/contador2
- }
- escreva("Digite a Frequência: ")
- leia(frequencia)
- escreva("A média final: "+MediaFinal)
- se (MediaFinal>=5 e frequencia>=75){
- escreva("\n"+nome+" foi Aprovado")
- }
- senao{
- escreva("\n"+nome+" foi Reprovado")
- }
- escreva("\nDigite s para sair ou apenas ENTER para continuar: ")
- leia(resposta)
- se(resposta=='s' ou resposta=='S'){
- retorne falso
- }
- retorne verdadeiro
- }
- }
Ele poderia ser mais aprimorado, não acha? Experimente modificá-lo.
Referências
MANZANO, J. A. N. G. Portugol Studio: Programação de Computadores em Português. São Paulo: Propes Vivens, 2017. 86p
NOSCHANG, LUIZ et all. Portugol Studio: Uma IDE para Iniciantes em Programação. In: XXXIV Congresso da Sociedade Brasileira de Computação - CSBC, 34º, 2014, Brasília, Anais Eletrônicos do Congresso da Sociedade Brasileira de Computação, Brasília, 2014. p. 1287 - 1296. Disponível em: <https://sol.sbc.org.br/index.php/wei/article/view/10954/10824>. Acesso em: 4 ago. 2024.
PORTUGOL WEBSTUDIO. Ajuda. Disponível em: <https://portugol.dev/> Acesso em 05 ago. 2024.
PORTUGOL WEBSTUDIO. Dúvidas e Perguntas. Disponível em: <https://portugol.dev/> Acesso em 05 ago. 2024.