<Direto ao Ponto 44> As funções e os procedimentos
- #Informática Básica
Artigos desta série: ( < ) Anterior | Índice | Seguinte ( > )
Olá, dev!
Este é mais um artigo da série DIRETO AO PONTO, que eu estou escrevendo para a DIO. Ele vai tratar do último bloco de programação com comandos múltiplos que eu planejei, as funções e os procedimentos.
Sumário
1. Introdução
2. O funcionamento de funções e procedimentos
3. Definição de funções e procedimentos
4. Considerações finais
5. Referências
1 – Introdução
Eu criei a série de artigos DIRETO AO PONTO com o objetivo de apresentar, de forma simples e direta, conhecimentos básicos da programação e de computação, principalmente, para os iniciantes.
Aqui, são tratados de temas como lógica de programação, linguagens, hardware dos computadores, história da computação e assuntos relacionados à plataforma da DIO, como a escrita de artigos e os desafios de código.
Neste artigo, eu vou falar sobre as funções e procedimentos, o último dos blocos de programação com comandos múltiplos que eu planejei falar nesta série. No artigo anterior, eu tratei dos comandos de repetição.
As funções são blocos de comandos múltiplos que realizam uma determinada operação em dados que podem se repetir várias vezes em um programa, o mesmo ocorrendo com os procedimentos.
Mas, Fernando! Você tinha falado no artigo anterior que os comandos de repetição faziam isso mesmo. A mesma coisa!
Bem, os comandos de repetição são usados para repetir um bloco de instruções que são usadas SEQUENCIALMENTE, em um único momento, com dados que chegam um atrás do outro. Por exemplo, para ler as notas de vários alunos e determinar quem foi aprovado ou não, para ler todos os elementos de um vetor de uma só vez e processá-los, um a um.
Já uma função (ou um procedimento) aproveita um conjunto de instruções e junta tudo em um bloco só, que é processado da mesma forma, sempre que aquele processamento for necessário. Por exemplo, uma função que calcule o valor do fatorial de um número, geralmente usado em operações de combinatória matemática, mas apenas quando este cálculo for necessário no programa. Ou então, quando é preciso escrever uma mesma mensagem, na tela diversas vezes, sempre que ela for necessária, por exemplo, a lista de opções de um menu.
A diferença básica entre uma função e um procedimento é que a função sempre retorna um valor para a instrução que a chamou, enquanto o procedimento não retorna nada. O exemplo do fatorial é típico para a implementação de uma função, ao passo que a escrita das opções de um menu é implementada com um procedimento.
Daqui para a frente, sempre que eu falar de função, entenda que também se aplica a um procedimento, a não ser a questão do retorno de valor para a instrução que a chamou.
2 – O funcionamento de funções e procedimentos
Uma função (ou um procedimento) é composto de um bloco de instruções que são executadas após a função ser chamada.
Ela possui um nome, um tipo de retorno e pode ter parâmetros. Basicamente, o nome dela segue as mesmas regras da linguagem para a nomenclatura de variáveis. O tipo de retorno determina se o valor retornado por ela, ao final do processamento é inteiro, real, lógico, um string, etc.
Os parâmetros são valores que podem ser passados para a função processá-los para gerar um resultado e retorná-lo. Uma função pode ter parâmetros ou não.
Além disso, uma função deve ser chamada por uma instrução do programa para que ela seja executada.
Um esboço de uma função é mostrado a seguir, mostrando as entradas (dados), o processamento interno e a saída (resultado), cujo valor é retornado para a instrução que a chamou:
Exemplo de função, em Python:
Definição da função cubo()
def cubo( x ):
return x * x * x
Chamada da função cubo, com 1 parâmetro
print( cubo( 3 ) )
Desta forma, a execução de um programa com esta chamada à função cubo acima resultaria na impressão do valor 27, ou seja, 3 * 3 * 3. Note que a função poderia ser chamada com valores diferentes de 3, sempre retornando o valor do cubo do número da chamada - cubo(1) retornaria 1; cubo( 2), retornaria 8 e assim por diante.
Um exemplo de procedimento, também em Python:
Definição da função mostraMenu()
def mostramenu():
print(“Informe uma opção (entre 1 e 4):”)
print(“1 – Abrir arquivo”)
print(“2 – Salvar arquivo”)
print(“3 – Imprimir arquivo”)
print(“4 – Sair do programa”)
Chamada do procedimento mostraMenu(), sem parâmetros
mostraMenu()
Desta forma, a execução de um programa com esta chamada à função mostraMenu acima resultaria na impressão das linhas abaixo, toda vez que ele fosse chamado:
Informe uma opção (entre 1 e 4):
1 – Abrir arquivo
2 – Salvar arquivo
3 – Imprimir arquivo
4 – Sair do programa
Note a diferença entre uma função, que retorna um valor para a instrução que a chamou, e um procedimento, que não retorna nada após executar seu bloco de instruções.
COMO FUNCIONA A PASSAGEM DE PARÂMETROS PARA UMA FUNÇÃO
Eu vou explicar agora como ocorre a passagem dos valores dos parâmetros do programa principal para uma e como ocorre o retorno do valor da função de volta para o programa principal.
OBS: Aviso aos puristas que a maneira como vou explicar o processo agora é uma versão muito simplificada, por questões de simplicidade didática. Os conceitos envolvidos são mais completos, mas uma explicação detalhada foge dos objetivos dos artigos desta série. Qualquer material sobre o assunto de gerenciamento de memória nas chamadas a funções, para a linguagem C, pode descrever melhor, e com mais detalhes, esta operação, com conceitos e estruturas mais técnicos.
Considere o exemplo a seguir, codificado na linguagem C: Um programa principal chama uma função que realiza a soma de duas variáveis, passadas como parâmetros para a função, por valor:
// Programa principal
#include <stdio.h>
int main() {
// Variáveis locais do programa principal
int x = 5;
int y = 10;
int total;
// Chamada da função e atribuição do valor retornado à variável total
total = somar(x, y);
// Mostra o resultado
printf("Resultado da soma: %d\n", total);
return 0;
}
// Função que soma dois números e retorna o resultado da soma
int somar(int a, int b) {
int resultado = a + b; // Variável local da função
return resultado; // Retorna o valor da variável para o programa principal
}
Explicação:
Quando uma função é chamada (incluindo a função main), é criada uma estrutura para ela (chamada “frame de ativação”), numa pilha de execução (pilha de chamadas). Acompanhe as ações da execução da função chamada.
Quando o programa principal - main( ) - é iniciado:
· É criado um frame de ativação, na pilha de chamadas, para a função main();
· As variáveis x, y e total, de main(), são colocadas na pilha de chamadas, no frame de ativação de main() (figura 1A);
Durante a chamada à função somar(x, y):
· Um novo frame de ativação para a função somar() é criado na pilha de chamadas;
· As variáveis a, b e resultado, da função somar(), são alocadas na pilha de chamadas, no frame de ativação da função somar() (figura 1B);
· Os valores de x e y são copiados (passados) para as variáveis (parâmetros) a e b, da função somar() (figura 1C);
· A soma de a e b é calculada e armazenada na variável resultado (figura 1D);
· O valor da variável resultado é retornado para main(), copiado para a variável total, de main() (figura 1E);.
Após o retorno da função somar():
· O frame da função somar() é removido da pilha (desempilhado), liberando a memória dos parâmetros e variáveis locais dela (figura 1F);
· A execução retorna para main(), agora com a variável total contendo o valor retornado de somar().
· A instrução de saída printf() imprime o valor da variável total.
Veja a seguir uma figura que ilustra este processo:
OBS: Mesmo que os nomes das variáveis locais da função soma() fossem os mesmos da função principal, main(), os valores dos parâmetros da função seriam copiados das variáveis originais da função main() e elas seriam variáveis diferentes daquelas, portanto, se os valores delas (a e b) fossem alterados dentro da função soma(), eles não afetariam os valores das variáveis x e y, da função principal.
As linguagens de programação oferecem uma maneira de se passar para dentro de uma função a variável original da chamada, de forma que seu valor possa ser alterado dentro da função chamada. É a chamada por referência (diferente da chamada por valor, que vimos aqui), que passa para a função o endereço da variável de chamada.
Este assunto será tratado em outro artigo sobre funções, que trata de formas mais avançadas de funções (arrow functions, apontadores, lambda functions, paradigma funcional etc.).
3 – Definição de funções e procedimentos
As primeiras linguagens de programação já ofereciam funções e procedimentos, cujas sintaxes e implementações mudaram com os anos, mas o funcionamento básico se mantém. Veja exemplos de funções a seguir, em várias linguagens. Veja como a sintaxe muda de um linguagem para outra, seja na chamada ou na definição da função (palavra-chave, parâmetros, tipos, delimitadores de bloco, etc.):
3.1 - PYTHON
Função
def somar(a, b):
return a + b
chamada:
print(somar( 2, 3 ) )
A função retorna 2 + 3 e a saída do programa é: 5
Procedimento
def mostrar_mensagem( ):
print("Hello world!")
chamada:
print(mostrar_mensagem( ) )
A saída do programa é: “Hello world!”
A função (como é um procedimento) retorna None implicitamente.
3.2 - C
Função
int somar(int a, int b) {
return a + b;
}
chamada:
printf(“%d\n”, somar( 1, 2 ) );
A saída é: 3
Note que o tipo de retorno da função é inteiro (int).
Procedimento
void mostrar_mensagem() {
printf("Hello world!\n");
}
chamada:
printf(“%s\n”, mostrar_mensagem( ) );
A saída do programa é: “Hello world!”
A função (como é um procedimento) retorna void (void indica que não há retorno).
3.3 - PASCAL
Função
function Somar(a, b: Integer): Integer;
begin
Somar := a + b;
end;
Chamada:
WriteLn(Somar(3, 4));
Note que o tipo de retorno da função é inteiro (Integer).
Procedimento
procedure MostrarMensagem;
begin
WriteLn('Olá, mundo!');
end;
Chamada:
MostrarMensagem;
O procedimento não tem retorno.
3.4 - FORTRAN
Função
integer function somar(a, b)
integer :: a, b
somar = a + b
end function somar
Chamada:
print *, somar(3, 4)
O tipo de retorno da função é inteiro (integer).
Procedimento (sub-rotina)
subroutine mostrar_mensagem()
print *, "Olá, mundo!"
end subroutine mostrar_mensagem
Chamada:
call mostrar_mensagem()
O procedimento (sub-rotina) não tem retorno.
3.5 - C#
Função
class Program {
static int Somar(int a, int b) {
return a + b;
}
Chamada:
Program.Somar( 10, 20 );
O tipo de retorno da função é inteiro (int).
Procedimento
static void MostrarMensagem() {
Console.WriteLine("Olá, mundo!");
}
}
Chamada:
Program.MostrarMensagem();
A função (como é um procedimento) retorna void (sem retorno).
3.6 - JAVA
Função
public class Main {
// Função que retorna um valor
static int somar(int a, int b) {
return a + b;
}
Chamada:
Program.somar( 10, 20 );
Note que o tipo de retorno da função é inteiro (int).
Procedimento
static void mostrarMensagem() {
System.out.println("Olá, mundo!");
}
}
Chamada:
Program.mostrarMensagem();
A função (como é um procedimento) retorna void (sem retorno).
3.7 - KOTLIN
Função
fun somar(a: Int, b: Int): Int {
return a + b
}
Chamada:
somar( 100, 5 )
Procedimento
fun mostrarMensagem() {
println("Olá, mundo!")
}
Chamada:
mostrarMensagem()
A função (como é um procedimento) retorna Unit implicitamente (mesmo que void, sem retorno).
3.8 - PHP
Função
function somar($a, $b) {
return $a + $b;
}
Chamada:
somar( 0, 1 );
Procedimento
function mostrar_mensagem() {
echo "Olá, mundo!";
}
Chamada:
mostrar_mensagem();
4 – Considerações finais
Este é mais um artigo da série DIRETO AO PONTO, que eu estou escrevendo para a DIO.
Desta vez, eu falei sobre as funções e procedimentos, o último dos comandos de blocos múltiplos que eu havia planejado.
As funções são blocos de comandos múltiplos que realizam uma determinada tarefa que podem se repetir várias vezes em um programa.
A diferença básica de uma função para um procedimento é que a função retorna um valor para a instrução que a chamou, enquanto o procedimento não retorna nada.
Um exemplo típico de função calcula o fatorial de um número inteiro. Para um procedimento é a escrita das opções de um menu.
No próximo artigo, eu vou começar a falar de começar a falar sobre um tema importantíssimo na programação: as estruturas de dados.
5 – Referências
Praticamente todo o conteúdo deste artigo foi tirado do que eu aprendi (e me lembro) sobre o assunto desde o início da minha carreira como programador, desde os anos 80 até agora.
Para a elaboração dos códigos com os detalhes dos comandos oferecidos pelas diversas linguagens de programação usadas aqui, eu consultei as ferramentas ChatGPT e Copilot.
Artigos desta série: ( < ) Anterior | Índice | Seguinte ( > )