Função: modularização de algoritmos
Aprenda a técnica de modularização de algoritmos. Uma função permite dividir o código fonte em módulos separados e comunicáveis entre si.
09/11/2023
O conceito de função é o último assunto da programação básica que você deve aprender. É recomendado que, antes de ler este artigo, você já possua o conhecimento dos assuntos anteriores. Portanto, vale a pena você clicar aqui e dar uma olhada nesses outros assuntos. Quem sabe tem algum que você deixou passar?
Bom! Mas vamos ao que interessa!
Começando a entender uma Função
O principal objetivo da modularização é dividir o código fonte em partes menores. Partes estas que façam trabalhos específicos e que sejam mais gerenciáveis e fáceis de modificar.
Na programação de computadores, a modularização é conseguida por meio da implementação de um recurso conhecido como função.
Você pode pensar em uma função como sendo uma sequência de comandos com um nome próprio. Uma espécie de agrupamento de comandos.
Vamos entender isso direito!
Imagine que tenhamos um algoritmo que:
- Apresenta algumas mensagens de boas-vindas;
- Cria 3 variáveis;
- inicializa as 3 variáveis com valores digitados pelo usuário.
- Cria uma 4ª variável com o resultado da soma da 1ª variável com a 2ª;
- Cria uma 5ª variável com o resultado da multiplicação da 2ª variável com a 3ª;
- Imprime na tela o valor das 5 variáveis.
Observe abaixo o código desse algoritmo:
1.void main(){
2. // boas-vindas
3. println("Olá");
4. println("Seja Bem vindo ao Sistema!");
5.
6. // criação das 3 variáveis
7. int var1, var2, var3;
8.
9. // inicialização
10. println("Digite um valor:");
11. var1 = input();
12. println("Digite um valor:");
13. var2 = input();
14. println("Digite um valor:");
15. var3 = input();
16.
17. // operação soma
18. int var4 = var1 + var2;
19.
20. // operação multiplicação
21. int var5 = var2 * var3;
22.
23. // impressão variaveis
24. println("Valor1: "+var1);
25. println("Valor2: "+var2);
26. println("Valor3: "+var3);
27. println("Valor4: "+var4);
28. println("Valor5: "+var5);
29.}
OBS: O termo “void main()” (linha 1 do código acima) refere-se à função principal do algoritmo. Na maioria das linguagens de programação, os comandos devem ser escritos dentro de uma função principal, que representa o ponto de partida de um programa. No entanto, é importante observar que existem exceções, tais como as linguagens Python e Javascript, que não possuem função principal.
É possível perceber que o algoritmo anterior realiza 4 tipos de atividades distintas:
- Solicitação de valores;
- Uma operação de Soma;
- Uma operação de Multiplicação;
- E algumas impressões.
É obvio que o código acima é simples de ser compreendido. Mas, a depender do tamanho do código, não seria ruim deixar muitas atividades dentro de um mesmo escopo? Não seria interessante se houvesse a possibilidade de separar (modularizar) essas atividades em blocos de código distintos? Quem sabe até em outros arquivos?
E é justamente isso que uma função faz! Ela permite separar trechos do seu algoritmo em um outro fragmento de código, que pode estar no mesmo arquivo ou até em outro arquivo.
Vamos ver como podemos fazer isso!
Criando uma Função Simples
Vamos retomar o algoritmo anterior:
1.void main(){
2. // boas-vindas
3. println("Olá");
4. println("Seja Bem vindo ao Sistema!");
5.
6. // criação das 3 variáveis
7. int var1, var2, var3;
8.
9. // inicialização
10. println("Digite um valor:");
11. var1 = input();
12. println("Digite um valor:");
13. var2 = input();
14. println("Digite um valor:");
15. var3 = input();
16.
17. // operação soma
18. int var4 = var1 + var2;
19.
20. // operação multiplicação
21. int var5 = var2 * var3;
22.
23. // impressão variaveis
24. println("Valor1: "+var1);
25. println("Valor2: "+var2);
26. println("Valor3: "+var3);
27. println("Valor4: "+var4);
28. println("Valor5: "+var5);
29.}
Imagine que precisamos separar em outro bloco de código a impressão das mensagens de boas-vindas (linhas 3 e 4 do código acima).
Para isso, podemos criar uma função denominada “boasVindas”. Essa função teria apenas o objetivo de imprimir as mensagens. O código abaixo mostra essa função:
1.void boasVindas(){
2. println("Olá");
3. println("Seja Bem vindo ao Sistema!");
4.}
A sua estrutura pode parecer um pouco confusa à primeira vista, mas vamos explicar em detalhes os seus componentes:
- void – palavra reservada que indica que a função não retorna valores (o conceito de retorno será detalhado mais adiante)
- boasVindas – é o nome da função. Pode ser o nome que você preferir, desde que represente o objetivo da função.
- ( ) – os parênteses é o detalhe marcante de uma função. Dentro deles são escritos os parâmetros da função. Caso a função não receba parâmetros, eles ficam vazios, mas sempre devem existir (os parâmetros serão detalhado mais adiante).
- { } – as chaves delimitam o escopo da função. Dentro delas colocamos todos os comandos que queremos separar do bloco principal do algoritmo.
Essa separação de código é o que chamamos de modularização!
Desta forma, o código principal do algoritmo fica da seguinte maneira:
1.void boasVindas(){
2. println("Olá");
3. println("Seja Bem vindo ao Sistema!");
4.}
5.
6.void main(){
7. boasVindas();
8.
9. // criação das 3 variáveis
10. int var1, var2, var3;
11.
12. // inicialização
13. println("Digite um valor:");
14. var1 = input();
15. println("Digite um valor:");
16. var2 = input();
17. println("Digite um valor:");
18. var3 = input();
19.
20. // operação soma
21. int var4 = var1 + var2;
22.
23. // operação multiplicação
24. int var5 = var2 * var3;
25.
26. // impressão variaveis
27. println("Valor1: "+var1);
28. println("Valor2: "+var2);
29. println("Valor3: "+var3);
30. println("Valor4: "+var4);
31. println("Valor5: "+var5);
32.}
Observe na linha 7 do código acima que os comandos de impressão das mensagens de boas-vindas foram retirados. Agora eles estão dentro do corpo da função “boasVindas()” (linhas 1 a 4 do código acima).
O comando boasVindas() (linha 7 do código acima) representa o que denominamos de invocação da função. É ele o responsável por desviar a execução do algoritmo para a linha 1 (código acima) e imprimir as mensagens de boas-vindas.
Portanto, a criação de uma função se divide em duas partes:
- A declaração da função – o seu corpo:
1.void boasVindas(){
2. println("Olá");
3. println("Seja Bem vindo ao Sistema!");
4.}
- A invocação da função – o comando que irá desviar a execução do algoritmo:
1.boasVindas();
Veja na animação abaixo a simulação da execução, linha por linha, do algoritmo com a função “boasVindas()”.
Criando uma Função com Retorno
Vamos retomar o mesmo algoritmo anterior, do ponto onde paramos:
1.void boasVindas(){
2. println("Olá");
3. println("Seja Bem vindo ao Sistema!");
4.}
5.
6.void main(){
7. boasVindas();
8.
9. // criação das 3 variáveis
10. int var1, var2, var3;
11.
12. // inicialização
13. println("Digite um valor:");
14. var1 = input();
15. println("Digite um valor:");
16. var2 = input();
17. println("Digite um valor:");
18. var3 = input();
19.
20. // operação soma
21. int var4 = var1 + var2;
22.
23. // operação multiplicação
24. int var5 = var2 * var3;
25.
26. // impressão variaveis
27. println("Valor1: "+var1);
28. println("Valor2: "+var2);
29. println("Valor3: "+var3);
30. println("Valor4: "+var4);
31. println("Valor5: "+var5);
32.}
Agora vamos separar (modularizar) as operações de inicialização, que solicita valores do usuário (linhas 13 a 18 do código acima).
Observe que a inicialização de cada variável consiste em imprimir a mensagem “Digite um valor:” e solicitar o valor digitado no teclado pelo comando “input()”. Para essa modularização, podemos criar uma função denominada “digitaValor”. O código abaixo mostra essa função.
1.int digitaValor(){
2. println("Digite um valor:");
3. int var = input();
4. return var;
5.}
A declaração dessa função parece mais complicada do que a da seção anterior. Aqui incluímos a palavra int no lugar do void (linha 1 do código acima) e a palavra return (linha 4 do código acima).
O termo int se refere ao tipo de retorno da função. Significa que essa função vai retornar (para quem a invocou) um valor do tipo inteiro. E esse retorno é realizado no final da função pela palavra return.
Desta forma, o código principal do algoritmo fica da seguinte maneira:
1.void boasVindas(){
2. println("Olá");
3. println("Seja Bem vindo ao Sistema!");
4.}
5.
6.int digitaValor(){
7. println("Digite um valor:");
8. int var = input();
9. return var;
10.}
11.
12.void main(){
13. boasVindas();
14.
15. // criação das 3 variáveis
16. int var1, var2, var3;
17.
18. var1 = digitaValor();
19. var2 = digitaValor();
20. var3 = digitaValor();
21.
22. // operação soma
23. int var4 = var1 + var2;
24.
25. // operação multiplicação
26. int var5 = var2 * var3;
27.
28. // impressão variaveis
29. println("Valor1: "+var1);
30. println("Valor2: "+var2);
31. println("Valor3: "+var3);
32. println("Valor4: "+var4);
33. println("Valor5: "+var5);
34.}
É possível observar nas linhas 6 a 10 do código acima a declaração da função “digitaValor()”.
Também é possível observar nas linhas 18 a 20 do código acima que os comandos de solicitação foram removidos. No seu lugar, foram colocados os comandos de invocação da função “digitaValor()”. O diferencial aqui é que essas invocações estão sendo atribuídas às variáveis var1, var2 e var3. Isso é possível, pois a função “digitaValor()” possui um retorno, que é enviado de volta e atribuído às variáveis var1, var2 e var3.
Veja na animação abaixo a simulação da execução, linha por linha, do algoritmo com a função “digitaValor()”.
Criando uma Função com Parâmetros
Já aprendemos a criar funções simples (que não retornam nada) e funções com retorno (que retornam valores). Agora vamos aprender a criar funções com parâmetros (que enviam valores).
Para isso, vamos retomar o mesmo algoritmo anterior, do ponto onde paramos:
1.void boasVindas(){
2. println("Olá");
3. println("Seja Bem vindo ao Sistema!");
4.}
5.
6.int digitaValor(){
7. println("Digite um valor:");
8. int var = input();
9. return var;
10.}
11.
12.void main(){
13. boasVindas();
14.
15. // criação das 3 variáveis
16. int var1, var2, var3;
17.
18. var1 = digitaValor();
19. var2 = digitaValor();
20. var3 = digitaValor();
21.
22. // operação soma
23. int var4 = var1 + var2;
24.
25. // operação multiplicação
26. int var5 = var2 * var3;
27.
28. // impressão variaveis
29. println("Valor1: "+var1);
30. println("Valor2: "+var2);
31. println("Valor3: "+var3);
32. println("Valor4: "+var4);
33. println("Valor5: "+var5);
34.}
Vamos modularizar a operação de soma. Para isso, podemos criar uma função denominada “soma”. Essa função terá apenas o objetivo de somar dois valores enviados por parâmetro (entre os parênteses ‘(‘ ‘)’ da função).
Veja abaixo o código dessa função:
1.int soma(int a, int b){
2. int var = a + b;
3. return var;
4.}
O código acima ilustra a criação de uma função que possui a capacidade de receber parâmetros. Observe na linha 1 do código acima que existe, dentro dos parênteses, a declaração das duas vaiáveis inteiras “a” e “b”. Essas variáveis são os parâmetros da função. Elas receberão os valores a serem somados quando a função “soma()” for invocada. Veja abaixo um exemplo de como podemos invocar essa função e passar os parâmetros:
1.int soma(int a, int b){
2. int var = a + b;
3. return var;
4.}
5.
6.void main(){
7. int resultado = soma(5, 8);
8.}
A linha 7 do código acima mostra a invocação da função “soma()” com a passagem dos parâmetros. Os valores 5 e 8 são passados, respectivamente, para as variáveis “a” e “b” (linha 1 do código acima). Após isso, os valores são somados (linha 2 do código acima), resultando no valor 13. Em seguida, o valor 13 é retornado (linha 3 do código acima). Por fim, esse valor 13 retornado é atribuído à variável “resultado” (linha 7 do código acima).
Veja na animação abaixo a simulação da execução do código acima:
OBS: quando uma função possui parâmetros em sua declaração, a passagem desses parâmetros é obrigatória durante a sua invocação!
Seguindo o mesmo raciocínio, podemos criar uma função para realizar a multiplicação:
1.int multiplica(int a, int b){
2. int var = a * b;
3. return var;
4.}
Veja abaixo o algoritmo completo com todas as operações já modularizadas e em várias linguagens de programação diferentes:
1.import java.util.Scanner;
2.class Main {
3. public static void boasVindas(){
4. System.out.println("Olá");
5. System.out.println("Seja Bem vindo ao Sistema!");
6. }
7. public static int digitaValor(){
8. System.out.println("Digite um valor:");
9. Scanner sc = new Scanner(System.in);
10. int var = sc.nextInt();
11. return var;
12. }
13. public static int soma(int a, int b){
14. int var = a + b;
15. return var;
16. }
17. public static int multiplica(int a, int b){
18. int var = a * b;
19. return var;
20. }
21. public static void main(String[] args) {
22. boasVindas();
23. // criação das 3 variáveis
24. int var1, var2, var3;
25. // solicitação dos valores
26. var1 = digitaValor();
27. var2 = digitaValor();
28. var3 = digitaValor();
29. // operações matemáticas
30. int var4 = soma(var1, var2);
31. int var5 = multiplica(var2, var3);
32. // impressão variaveis
33. System.out.println("Valor1: "+var1);
34. System.out.println("Valor2: "+var2);
35. System.out.println("Valor3: "+var3);
36. System.out.println("Valor4: "+var4);
37. System.out.println("Valor5: "+var5);
38. }
39.}
1.#include <stdio.h>
2.void boasVindas(){
3. printf("Olá\n");
4. printf("Seja Bem vindo ao Sistema!\n");
5.}
6.int digitaValor(){
7. printf("Digite um valor:\n");
8. int var;
9. scanf("%d",&var);
10. return var;
11.}
12.int soma(int a, int b){
13. int var = a + b;
14. return var;
15.}
16.int multiplica(int a, int b){
17. int var = a * b;
18. return var;
19.}
20.int main(void) {
21. boasVindas();
22. // criação das 3 variáveis
23. int var1, var2, var3;
24. // solicitação dos valores
25. var1 = digitaValor();
26. var2 = digitaValor();
27. var3 = digitaValor();
28. // operações matemáticas
29. int var4 = soma(var1, var2);
30. int var5 = multiplica(var2, var3);
31. // impressão variaveis
32. printf("Valor1: %d\n",var1);
33. printf("Valor2: %d\n",var2);
34. printf("Valor3: %d\n",var3);
35. printf("Valor4: %d\n",var4);
36. printf("Valor5: %d\n",var5);
37.}
1.#include <iostream>
2.void boasVindas(){
3. std::cout << "Olá\n";
4. std::cout << "Seja Bem vindo ao Sistema!\n";
5.}
6.int digitaValor(){
7. std::cout << "Digite um valor:\n";
8. int var;
9. std::cin >> var;
10. return var;
11.}
12.int soma(int a, int b){
13. int var = a + b;
14. return var;
15.}
16.int multiplica(int a, int b){
17. int var = a * b;
18. return var;
19.}
20.int main() {
21. boasVindas();
22. // criação das 3 variáveis
23. int var1, var2, var3;
24. // solicitação dos valores
25. var1 = digitaValor();
26. var2 = digitaValor();
27. var3 = digitaValor();
28. // operações matemáticas
29. int var4 = soma(var1, var2);
30. int var5 = multiplica(var2, var3);
31. // impressão variaveis
32. std::cout << "Valor1: " << var1 << std::endl;
33. std::cout << "Valor2: " << var2 << std::endl;
34. std::cout << "Valor3: " << var3 << std::endl;
35. std::cout << "Valor4: " << var4 << std::endl;
36. std::cout << "Valor5: " << var5 << std::endl;
37.}
1.using System;
2.class MainClass {
3. public static void boasVindas(){
4. Console.WriteLine("Olá");
5. Console.WriteLine("Seja Bem vindo ao Sistema!");
6. }
7. public static int digitaValor(){
8. Console.WriteLine("Digite um valor:");
9. int var = Convert.ToInt32(Console.ReadLine());
10. return var;
11. }
12. public static int soma(int a, int b){
13. int var = a + b;
14. return var;
15. }
16. public static int multiplica(int a, int b){
17. int var = a * b;
18. return var;
19. }
20. public static void Main (string[] args) {
21. boasVindas();
22. // criação das 3 variáveis
23. int var1, var2, var3;
24. // solicitação dos valores
25. var1 = digitaValor();
26. var2 = digitaValor();
27. var3 = digitaValor();
28. // operações matemáticas
29. int var4 = soma(var1, var2);
30. int var5 = multiplica(var2, var3);
31. // impressão variaveis
32. Console.WriteLine("Valor1: "+var1);
33. Console.WriteLine("Valor2: "+var2);
34. Console.WriteLine("Valor3: "+var3);
35. Console.WriteLine("Valor4: "+var4);
36. Console.WriteLine("Valor5: "+var5);
37. }
38.}
1.def boasVindas():
2. print("Olá")
3. print("Seja Bem vindo ao Sistema!")
4.def digitaValor():
5. var = int(input("Digite um valor:"))
6. return var
7.def soma(a, b):
8. var = a + b
9. return var
10.def multiplica(a, b):
11. var = a * b
12. return var
13.boasVindas();
14.# solicitação dos valores
15.var1 = digitaValor()
16.var2 = digitaValor()
17.var3 = digitaValor()
18.# operações matemáticas
19.var4 = soma(var1, var2)
20.var5 = multiplica(var2, var3)
21.# impressão variaveis
22.print("Valor1: "+str(var1))
23.print("Valor2: "+str(var2))
24.print("Valor3: "+str(var3))
25.print("Valor4: "+str(var4))
26.print("Valor5: "+str(var5))
Se você já está familiarizado com todos os assuntos da programação básica, com certeza está preparado para estudar tópicos mais avançados da programação, tais como, Programação Orientada a Objetos e Estruturas de Dados.
O importante é você continuar aprendendo. A programação pode te proporcionar possibilidades maravilhosas.
David Santiago
Mestre em Sistemas e Computação. Graduado em Sistemas de Informação. Professor de Linguagem de Programação, Algoritmos, Estruturas de Dados e Desenvolvimento de Jogos Digitais.
Este artigo foi útil para você?
Então nos ajude a crescer e compartilhe-o com outras pessoas que se interessam por esse assunto!
