Lógica de Programação

Funções

Tópicos Abordados

• Declaração
• Chamada
• Variáveis locais e globais
• Passagem de parâmetros
• Retorno de valores
• Recursividade

Decomposição de Problemas

• Os algoritmos podem ser divididos em

várias partes
• Isto é especialmente importante para
algoritmos complexos
– Facilita o entendimento
– Foco em resolver apenas uma parte do
problema, e não o problema como um todo
• Estas subdivisões de um algoritmo são
chamadas funções

1
Funções

• Uma função é um bloco de código que tem o

objetivo de resolver uma parte do algoritmo
principal
A função deve ter
um nome único

função processar() {
...
}
Aqui dentro está o
código a ser executado
pela função

Chamando Funções

• Depois de criada, uma função pode ser

chamada
• O nome da função é utilizado

início {
escreva("Processando...");
processar();
escreva("Fim do Processamento");
}

A função é chamada
neste momento

Chamando Funções

• Quando uma função é chamada, o fluxo de

execução é desviado para ela

Bloco Função f()

ação 1
ação 1
ação 2
ação 2
f();
ação 3
ação 3
...
...
ação n
ação n

2
Funções e Variáveis

• As variáveis definidas dentro de uma função

são visíveis apenas dentro dela
– Tentar acessar a variável fora dela causará erro
• Variáveis declaradas desta forma são
chamadas de variáveis locais
– Possuem um escopo local, válido apenas no
interior da função

função f() { A variável valor só existe

real: valor; dentro da função f()
}

Funções e Variáveis

• Uma variável pode também ser considerada

uma variável global
• Neste caso, ela é declarada fora de qualquer
função
• Todas as funções conseguem acessá-la

global real: valor; Todas as funções podem

ler e alterar a variável valor

global identifica que a

variável é global

Passando Parâmetros para Funções

• É comum que uma função precise receber

valores de entrada para realizar
determinado processamento
– Por exemplo, uma função somar precisa
receber os números para efetuar a operação
• Fornecer dados de entrada para funções
significa passar parâmetros

3
Passando Parâmetros para Funções

Os parâmetros são
definidos como as
variáveis

função somar(real: x, real: y) {

real: result;
result = x + y; Parâmetros são
escreva(result); variáveis locais
}
Os valores dos
início { parâmetros são
real: n1; copiados no momento
real: n2; da chamada
n1 = 10;
n2 = 5; Se uma função recebe
somar(n1, n2); parâmetros, é
} obrigatório fornecê-los

Retornando Valores

• Determinadas funções precisam enviar um

dado de resposta para quem fez a chamada
• Estas funções podem retornar valores

função somar(real: x, real: y) -> real {

real: result;
result = x + y;
retorne result; Tipo de retorno
}

Quando uma função O valor retornado deve

retorna um valor, retorne ser compatível com o
deve ser utilizado tipo de retorno

Retornando Valores

• Quem fez a chamada, pode ler o valor

retornado, apesar de não ser obrigatório

início {
real: n1;
real: n2;
A variável onde a atribuição
real: r; ocorre deve ser compatível com
n1 = 10; o tipo de retorno da função
n2 = 5;
r = somar(n1, n2);
}

Atribui o valor retornado

da função à variável r

4
Retornando Valores

• O comando retorne pode ser utilizado em

funções que não retornam valores
• Quando chamado, finaliza a execução da
função

função mostra_valor(inteiro: v) {
se (v > 10) {
retorne;
} Se o parâmetro v for
escreva(v); maior que 10, não
} faz nada

Informações Importantes

• O bloco início pode ser considerado uma

função especial, por onde o programa
começa a executar
– Não recebe parâmetros
– Não retorna valores
• Alguns comandos já conhecidos são, na
verdade, funções
– leia, escreva, pot, rad, abra, feche, etc.
• Funções que não retornam valores podem
também ser chamadas de procedimentos

Recursividade

• Funções podem chamar outras funções

• Recursividade significa que uma função
chama ela mesma
Função f() Função f() Função f()

ação 1 ação 1 ação 1

ação 2 ação 2 ação 2
f(); f(); f(); ...
ação 3 ação 3 ação 3
... ... ... Quando parar
ação n ação n ação n de chamar?

5
Critério de Parada

• Toda função recursiva deve ter um critério

de parada
– Caso contrário as chamadas entrarão em um
loop infinito

função contar(inteiro: ini, inteiro: fim) {

escreva(ini);
contar(ini + 1, fim);
}

contar(1, 5);

Não existe critério de parada. A

função nunca para de executar

Critério de Parada

função contar(inteiro: ini, inteiro: fim) {

escreva(ini);

se (ini < fim) { Critério de parada

contar(ini + 1, fim);
}
}

contar(1, 5);

contar(1, 5) contar(2, 5) contar(3, 5) contar(4, 5) contar(5, 5)