Algoritmos e

Estruturas de Dados I
Subalgoritmos:
Funções e Procedimentos
Profa. Márcia Cristina Moraes
Profa. Milene Selbach Silveira
Material para estudo:
Forbellone, A. e Eberspächer, H. (2005)
 capítulo 6 (conceitos de modularização e escopo de
variáveis)
Subalgoritmos

 Muitos problemas com soluções complexas

podem ser divididos, sucessivamente em
problemas menores, com lógica mais
simples e de compreensão mais fácil. Em
vez de escrever um algoritmo grande,
escrevem-se vários algoritmos menores, os
quais em conjunto resolvem o problema
proposto.
Subalgoritmos e Modularização

 Trechos de algoritmo que efetuam cálculos

determinados, são chamados de
subalgoritmos.
 O processo de dividir problemas grandes em
um conjunto de problemas menores é
chamado de modularização.
Modularização: vantagens
 Dividir problemas grandes em vários problemas
menores, de menor complexidade, principalmente por
terem um número pequeno de variáveis e poucos
caminhos de controle (caminhos do início ao fim do
programa).
 Possibilidade de usar soluções gerais para classes de
problemas em lugar de soluções específicas para
problemas particulares.
 Evitar a repetição dentro de um mesmo algoritmo, de
uma sequência de ações em diferentes pontos.
 Permite delimitar o escopo (nível de abrangência) de
variáveis.
[Orth 2001]
Modularização: escopo de
váriáveis
 As variáveis definidas no interior de um módulo
são denominadas de variáveis locais. As
variáveis deste tipo são ativadas somente quando
aquele módulo começa a ser executado. Ocupam
memória somente até o final da execução do
módulo ao qual pertencem. Isto permite uma
otimização do uso da memória.
Modularização:
Variáveis Locais x Variáveis Globais

 Variáveis Globais: possuem seu valor válido

durante todo o algoritmo
 Variáveis Locais: somente são válidas dentro
do subalgoritmo ao qual fazem parte

Variáveis globais, válidas para o

Algoritmo Exemplo Algoritmo exemplo e todos os sub-
inteiro: a, b, c algoritmos que podem ser criados
Início
inteiro: x, y, z Variáveis locais, somente são válidas
.... para o algoritmo exemplo, não valem
Fim para nenhum subalgoritmo criado

Até o momento somente estávamos usando variáveis globais, agora vamos usar
variáveis locais.
Subalgoritmos: tipos
 A maioria das linguagens possui 2 formas de
implementar e usar subalgoritmos
(módulos):
 Função: calculam um único valor em função de
um ou mais parâmetros recebidos
 Procedimento: podem calcular um número
qualquer de valores, calculados ou não em
função dos parâmetros recebidos
 Função
tipo Função NomeF(tipo: Arg1, tipo: Arg2, ..., tipo: Argn)
Início
{Definição das variáveis locais}
.....
{conjunto de comandos}
NomeF  Expressão Retorno para o programa principal
Retorne da expressão calculada na função

Fim
Função
 Tipo: tipo de retorno da função (qualquer um dos
tipos existentes, por exemplo, inteiro, real, literal)
 NomeF: nome da função
 O número de argumentos depende do que se quer
fazer na função. O nome do argumento sempre vem
precedido do seu tipo
 NomeF  Expressão: indica o retorno da
expressão calculada na função para o programa
principal
 Retorne: indica o término da execução do
subalgoritmo e o retorno do controle para o
programa principal
Exemplo
Inteiro Função Soma(inteiro: a, b)
Início a e b: argumentos de entrada
res: variável local, armazena o valor que
inteiro: res será retornado pela função

res  a + b Como o valor calculado retorna para o

algoritmo principal?
Soma  res Soma  res
Retorne
Retorne
Fim Como passamos os argumentos para a
função? Através de passagem de
parâmetros.
Passagem de Parâmetros
 Passagem por valor: passa o valor das
variáveis para os argumentos
 inteiro Função Soma(inteiro: a, inteiro: b)
 a e b são argumentos passados por valores do tipo
inteiro
 Função Soma também pode ser escrita da seguinte
maneira:
▪ Inteiro Função Soma(inteiro: a,b)
▪ Quando mais de um valor é do mesmo tipo eles podem ser
separados por vírgulas
Passagem de Parâmetros
 Passagem por referência: passa o
endereço de memória da variável para o
argumento
 Inteiro Função Soma2(inteiro: ref a, inteiro: b)
 a é um argumento passado por referência e b é um
argumento passado por valor
 Isto significa que a recebe/armazena um endereço de
memória relacionada a uma variável e não o valor de
uma variável
Vamos com calma!!
Aprofundaremos este conceito
quando virmos Procedimentos
Chamada da Função
 Por enquanto só vimos a declaração de
uma função
 Para que ela seja efetivamente usada ela
precisa ser declarada e chamada
 Iremos chamar a função dentro do algoritmo
principal da seguinte maneira:
 NomeF(parâmetros)
 Parâmetros são os nomes das variáveis que
queremos enviar para a função
Passo a passo
Algoritmo Principal
Inteiro: x, y, resultado
Início
leia(x, y) 10 3
resultado  Soma(x, y)
escreva(resultado)
Fim

Inteiro Função Soma (inteiro: a, b)

Início
inteiro: res
res  a + b
Soma  res
Retorne
Fim
Chamada da Função
Algoritmo Principal
Inteiro: x, y, resultado
Início
leia(x, y)
resultado  Soma(x, y) Chama a função soma passando o valor
escreva(resultado) de x que é 10 e o valor de y que é 3
Fim

Inteiro Função Soma (inteiro: a, b) Sabe que é passagem por valor

Início Porque não tem ref na frente de a
inteiro: res e nem de b
res  a + b
Soma  res
Retorne
Fim
Chamada da Função
Algoritmo Principal
Inteiro: x, y, resultado
Início
leia(x, y)
resultado  Soma(x, y)
escreva(resultado)
Fim

a recebe o valor de x, ou seja 10

Inteiro Função Soma (inteiro: a, b) b recebe o valor de y ou seja 3
Início
Declara a variável res que é uma
inteiro: res
variável local, ou seja, somente
res  a + b
é válida dentro da função Soma
Soma  res
Retorne Parâmetros a e b somente são
Fim válidos dentro da função Soma
Chamada da Função
Algoritmo Principal
Inteiro: x, y, resultado
Início
leia(x, y)
resultado  Soma(x, y)
escreva(resultado)
Fim

Inteiro Função Soma (inteiro: a, b)

Início
inteiro: res
res  a + b res recebe a soma de 10 e 3,
ou seja, recebe 13
Soma  res
Retorne
Fim
Chamada da Função
Algoritmo Principal
Inteiro: x, y, resultado
Início
leia(x, y)
resultado  Soma(x, y)
escreva(resultado)
Fim

Inteiro Função Soma (inteiro: a, b)

Início
inteiro: res
res  a + b
Soma  res Nome da função recebe o valor a ser retornado
Retorne
Fim
Chamada da Função
Algoritmo Principal
Inteiro: x, y, resultado
Início
leia(x, y)
resultado  Soma(x, y)
escreva(resultado)
Fim

Inteiro Função Soma (inteiro: a, b)

Início
inteiro: res
res  a + b
Soma  res
Retorne Retorna o controle para o programa principal
Fim
Chamada da Função
Algoritmo Principal
Inteiro: x, y, resultado
Início
leia(x, y)
resultado  Soma(x, y) Resultado recebe o valor retornado por
escreva(resultado) Soma, ou seja, 13
Fim

Inteiro Função Soma (inteiro: a, b)

Início
inteiro: res
res  a + b
Soma  res
Retorne
Fim
Chamada da Função
Algoritmo Principal
Inteiro: x, y, resultado
Início
leia(x, y)
resultado  Soma(x, y)
escreva(resultado) Escreve o valor de resultado, ou seja, 13
Fim

Inteiro Função Soma (inteiro: a, b)

Início
inteiro: res
res  a + b
Soma  res
Retorne
Fim
Chamada da Função
Algoritmo Principal
Inteiro: x, y, resultado
Início
leia(x, y) Poderia substituir
resultado  Soma(x, y) estas 2 linhas por
escreva (Soma(x,y))
escreva(resultado)
Fim

Inteiro Função Soma (inteiro: a, b)

Início
inteiro: res
res  a + b
Soma  res
Retorne
Fim
 Exercício
Faça um algoritmo que lê um número inteiro e chama uma
função que verifica se este é um número par. O algoritmo
deve escrever o resultado da função (se retornou que o
número é par ou não).

Faça, também, a função que recebe o valor inteiro e

verifica se ele é um número par. A função deve retornar 1
caso o número seja par e 0 no caso contrário.
Procedimento
 Pode calcular um número qualquer de
valores
 Pode retornar valores se os mesmos são
passados por referência para o
subalgoritmo, caso contrário, o procedimento
não retorna nenhum valor
Procedimento
Procedimento NomeP(tipo: Arg1, tipo: Arg2,..., tipo:Argn)
Início
{Definição das variáveis locais}
.....
Fim

Pode retornar valores nos argumentos desde que eles sejam passados
por referência para o procedimento. Neste caso deve-se ter ao final do
procedimento uma atribuição para os argumentos que se deseja
retornar valores calculados dentro do procedimento.
Procedimento
Procedimento NomeP(tipo: Arg1, tipo: Arg2,..., tipo:Argn)
Início
{Definição das variáveis locais} Diferença para
a função??
.....
Fim

Pode retornar valores nos argumentos desde que eles sejam passados
por referência para o procedimento. Neste caso deve-se ter ao final do
procedimento uma atribuição para os argumentos que se deseja retornar
valores calculados dentro do procedimento.
Procedimento
 NomeP: nome do procedimento
 Da mesma forma que na função o
procedimento também deve ser chamado no
algoritmo principal
 NomeP(parâmetros)
 Na hora que o procedimento é chamado, os
valores (parâmetros) da chamada são
passados para os argumentos
correspondentes
Procedimento
 Argumentos de definição e parâmetros de
chamada devem corresponder em número, e
tipo e estar na mesma ordem
 Enquanto os argumentos de definição devem
ser obrigatoriamente variáveis, os
parâmetros de chamada podem ser
expressões.
Exemplo – Procedimento que
não retorna valor
Procedimento Soma(inteiro: a, b)
Início
inteiro: res
res  a + b
Escreva (“Resultado da soma = ”, res)
Fim
Chamada do Procedimento
Soma
Algoritmo Principal
inteiro: x, y
Início
Leia(x, y)
Chamada do procedimento soma passando
Soma(x,y) os parâmetros x e y por valor

Escreva(x,y) Valores de x e y não são alterados, pois

a passagem de parâmetros é por valor
Fim
Passo a Passo (1/6)
Algoritmo Principal
inteiro: x, y
Início
leia(x, y) 10 3
Soma(x, y)
escreva(x,y)
Fim

Procedimento Soma(inteiro: a, b)
Início
inteiro: res
res  a + b
Escreva(res)
Fim
Passo a Passo (2/6)
Algoritmo Principal
inteiro: x, y
Início
leia(x, y)
Soma(x, y) Chama o procedimento soma passando o
escreva(x,y) valor de x que é 10 e o valor de y que é 3
Fim

Procedimento Soma(inteiro: a, b) Sabe que é passagem por valor

Início Porque não tem ref na frente de
inteiro: res a e nem de b
res  a + b
Escreva(res)
Fim
Passo a Passo (3/6)
Algoritmo Principal
inteiro: x, y
Início
leia(x, y)
Soma(x, y)
escreva(x,y)
Fim

Procedimento Soma(inteiro: a, b) a recebe o valor de x, ou seja 10

Início b recebe o valor de y, ou seja 3
inteiro: res
Declara a variável res que é uma
res  a + b
variável local, ou seja, somente
Escreva(res)
é valida dentro da função Soma
Fim
Passo a Passo (4/6)
Algoritmo Principal
inteiro: x, y
Início
leia(x, y)
Soma(x, y)
escreva(x,y)
Fim

Procedimento Soma(inteiro: a, b)
Início
inteiro: res
res recebe a soma de 10 e 3,
res  a + b
ou seja, recebe 13
Escreva(res)
Fim
Passo a Passo (5/6)
Algoritmo Principal
inteiro: x, y
Início
leia(x, y)
Soma(x, y)
escreva(x,y)
Fim

Procedimento Soma(inteiro: a, b)
Início
inteiro: res
res  a + b
Escreva(res) Escreve o resultado
Fim
Passo a Passo (6/6)
Algoritmo Principal
inteiro: x, y
Início
leia(x, y)
Soma(x, y)
escreva(x,y) Escreve o valor de x e y, ou seja, 10 e 3
Fim

Procedimento Soma(inteiro: a, b)
Início
inteiro: res
res  a + b
Escreva(res)
Fim
Retomando...
 Passagem por referência: passa o endereço
de memória da variável para o argumento
 Procedimento Soma2(inteiro: ref a, inteiro: b)
 a é um argumento passado por referência e b é um
argumento passado por valor
 Isto significa que a recebe/armazena um endereço de
memória relacionada a uma variável e não o valor de
uma variável
 O valor do argumento a retorna alterado para o
algoritmo principal
Exemplo – procedimento
retorna valor na variável a
Procedimento Soma2(inteiro: ref a, b)
Início
res: inteiro
res  a + b
a  res Passagem por Referência:
Recebe o endereço de memória da variável
Fim
Chamada do Procedimento
Soma2
Algoritmo Principal
inteiro: x, y
Início
Leia(x, y)
Chamada do procedimento Soma2 passando
Soma2(x,y) os parâmetros x e y
Valor de x retorna alterado, não é mais o
Escreva(x,y) valor que possuía antes da chamada
Valor de y volta inalterado, pois foi passado
Fim por valor
Passo a Passo - Soma2 (1/5)
Algoritmo Principal
inteiro: x, y
Início
leia(x, y) 10 3
Soma2(x, y)
escreva(x,y)
Fim

Procedimento Soma2(inteiro: ref a, b)

Início
inteiro: res
res  a + b
a  res
Fim
Passo a Passo - Soma2 (2/5)
Algoritmo Principal
inteiro: x, y
Início
leia(x, y)
Soma2(x, y) Chamada do procedimento Soma2
Passa x por referência e y por valor
escreva(x,y)
Fim x y
[150] 10 3 [200]
Procedimento Soma2(inteiro: ref a, b)
Início a b
[150] 3
inteiro: res
res  a + b Endereço de x vai para a
Valor de y vai para b
a  res
Fim
Passo a Passo - Soma2 (3/5)
Algoritmo Principal
inteiro: x, y
Início
leia(x, y)
Soma2(x, y)
escreva(x,y)
Fim x y
[150] 10 3 [200]
Procedimento Soma2(inteiro: ref a, b)
Início a b res
[150] 3 13
inteiro: res
res  a + b res recebe o conteúdo do endereço de memória
apontado por a mais o valor de b.
a  res
Conteúdo apontado por a é 10 mais
Fim valor de b que é 3
Passo a Passo - Soma2 (4/5)
Algoritmo Principal
inteiro: x, y
Início
leia(x, y)
Soma2(x, y)
escreva(x,y)
Fim x y
[150] 13 3 [200]
Procedimento Soma2(inteiro: ref a, b)
Início a b res
[150] 3 13
inteiro: res
res  a + b
a  res Endereço de memória apontado por a recebe o valor
de res
Fim
Passo a Passo - Soma2 (5/5)
Algoritmo Principal
inteiro: x, y
Início
leia(x, y)
Soma2(x, y)
Escreve o valor de x e de y
escreva(x,y)
Valor de x foi alterado dentro do procedimento!
Fim x y
[150] 13 3 [200]
Procedimento Soma2(inteiro: ref a, b)
Início
inteiro: res
res  a + b
a  res
Fim
Exercício 1
 Faça um procedimento que dado dois
valores N e X, escreve os N primeiros
pares acima de X.

Passagem
por valor ou
por referência?
Exercício 2
 Faça um procedimento que recebe 2
parâmetros do tipo inteiro e retorna os
valores dos parâmetros trocados para o
algoritmo principal. Construa o algoritmo
principal e faça uma chamada este
procedimento.
E
agora?
Exercício 3
 Faça um procedimento que recebe 3 valores
inteiros por parâmetro e retorna-os ordenados
em ordem crescente. Use o procedimento
definido no exercício 2. Construa o algoritmo
principal e faça uma chamada a este
procedimento.
Bibliografia
 Orth, Afonso Inácio. Algoritmos e
Programação. Editora AIO. 2001.
 Forbellone, A. e Eberspacher, H. Lógica
de Programação: A Construção de
Algoritmos e Estruturas de Dados.
Makron Books, São Paulo, 3ª edição.
2005.