Siga-nos

Inscreva-se

Siga-nos

Inscreva-se

Função: modularização de algoritmos

Aprenda a técnica de modularização de algoritmos. As funções permitem dividir o código fonte em módulos separados e comunicáveis entre si.

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çãoboasVindas()” (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:

1. A declaração da função – o seu corpo:

1.void boasVindas(){

2.     println("Olá");

3.     println("Seja Bem vindo ao Sistema!");

4.}

2. A invocação da função – o comando que irá desviar a execução do algoritmo:

1.boasVindas();

Clique na animação abaixo e veja 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.

Clique na animação abaixo e veja 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).

Clique na animação abaixo para ver 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:

  • Java
  • C
  • C++
  • C#
  • Python

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 ou Estruturas de Dados.

O importante é você continuar aprendendo. A programação pode te proporcionar possibilidades maravilhosas.

Este artigo foi útil para você?

Então nos ajude a crescer e compartilhe-o com outras pessoas que se interessam por esse assunto!

Share on whatsapp
WhatsApp
Share on facebook
Facebook
Share on twitter
Twitter
Share on linkedin
LinkedIn
Share on email
Email

Siga-nos

Inscreva-se

O primeiro livro didático de programação para jogos digitais

Este site usa cookies para garantir que você obtenha a melhor experiência.