Universidade Federal de Ouro Preto - UFOP
Departamento de Computação - DECOM
Programação de Computadores I – BCC701
www.decom.ufop.br/moodle
1

Modularização do código:
◦ Divisão do problema em subproblemas
◦ Encapsulamento de detalhes de implementação




Maior legibilidade do código
Maior facilidade de depuração do código
Reaproveitamento de código
Desenvolvimento de programas top-down
2
DCC001 2013-1

Já usamos muitas funções pré-definidas
◦
◦
◦
◦

modulo(x,y)
abs(x)
plot2d(X,Y)
gsort...
E agora sabemos como definir novas
funções!!!!
3
4
DCC001 2013-1

Defina uma função combinações
que receba como parâmetros 2
inteiros n e k e retorne o número de
combinações de n objetos em grupos de
k objetos, dado pela fórmula
5
DCC001 2013-1
Para reaproveitar o código
fat = 1;
for i = 1:n
fat = fat*i;
end
devemos adaptá-lo para o cálculo dos
fatoriais de n, n-k e k
6
DCC001 2013-1
n=input("n="); k=input("k=");
fat_n = 1; // Cálculo do fatorial de n
for i = 1:n
fat_n = fat_n * i;
end
fat_n_k = 1; // Cálculo do fatorial de n-k
for i = 1:(n-k)
fat_n_k = fat_n_k * i;
end
fat_k = 1; // Cálculo do fatorial de k
for i = 1:k
fat_k = fat_k * i;
end
nComb = fat_n/(fat_n_k * fat_k)
7
DCC001 2013-1
Função combinacoes
nComb = fatorial(n)/(fatorial(n-k) * fatorial(k))
Uso do
Módulo
Função Fatorial
function fat = fatorial(n)
fat = 1;
for i = 1:n
fat = fat*i;
end
endfunction
Detalhes
do Módulo
8
DCC001 2013-1
9
DCC001 2013-1
function fat = fatorial(n)
fat = 1;
for i = 1:n
fat = fat*i;
end
endfunction
10
DCC001 2013-1
function fat = fatorial(n)
fat = 1;
for i = 1:n
fat = fat*i;
Parâmetro de
end
Entrada
É fornecido na
Parâmetro
de Saída
endfunction
É calculado pela
função
chamada da
função
11
DCC001 2013-1
function [r1, r2] = eq2g(a,b,c)
delta = b^2 - 4*a*c
r1 = (-b + sqrt(delta))/(2*a)
r2 = (-b - sqrt(delta))/(2*a)
endfunction
Chamada da função eq2g
[raiz1,raiz2] = eq2g(x,y,z)
12
DCC001 2013-1



Valores dos argumentos de entrada (que
podem ser expressões) são copiados sobre
os parâmetros da função
O controle é transferido para a função, que
opera sobre os valores dos parâmetros
Os parâmetros da função somente têm
existência como variáveis durante a
execução da função
13
DCC001 2013-1



Alterações feitas pela função sobreos valores
dos parâmetros formais não afetam os
argumentos passados para a função
Variáveis utilizadas pela função não têm nada
a ver com variáveis de mesmo nome
existentes no programa que chama a função;
Estas variáveis locais ganham existência
somente durante a execução da função
14
DCC001 2013-1
Os parâmetros de saída
(normalmente termos em uma
expressão, como em y = 1 +
sin(x) ) recebem os valores
calculados pela função
 O controle é devolvido para o ponto
de chamada

15
DCC001 2013-1
//Combinações de n k a k
exec("fatorial.sci");
n = input("n = ");
k = input("k = ");
printf("\nAntes da chamada de fatorial(n)");
pause;
fat_n = fatorial(n);
printf("\nAntes da chamada de fatorial(k)");
pause;
fat_k = fatorial(k);
printf("\nAntes da chamada de fatorial(n-k)");
pause
fat_n_k = fatorial(n-k);
Comb_n_k = fat_n/(fat_k * fat_n_k);
printf("Comb(%d,%d) = %d",n,k,Comb_n_k)
16
DCC001 2013-1
function fat = fatorial(v)
printf("\nIniciando fatorial(%d)",v);
pause;
fat = 1;
for i = 1:v
fat = fat*i
end
printf("\nTerminando fatorial(%d)",v);
pause;
endfunction
17
DCC001 2013-1
18
DCC001 2013-1
function nComb = Combinacoes(n,k)
nComb = fatorial(n)/...
(fatorial(n-k) * fatorial(k))
endfunction
Nosso
programa
transformado
em função
Programa principal
exec("Combinacoes.sci")
exec("fatorial.sci")
n=input("n="); k=input("k=");
printf("nComb(%d,%d) = %d",n,k,Combinacoes(n,k))
19
DCC001 2013-1
Programa
Principal
Função
nComb
Função
Fatorial
20
DCC001 2013-1

Parâmetros de entrada e de saída de uma
função podem ser qualquer coisa:
◦
◦
◦
◦
◦
números,
strings,
booleanos,
matrizes de qualquer tipo,
e até mesmo outra função!
function plotaPontos(f,x)
y = f(x);
plot2d(x,y);
endfunction
21
DCC001 2013-1
function y = minhaFunc(x)
y = exp(- x .^ 2);
endfunction
// Testador PlotaPontos
exec(“plotaPontos.sci");
exec(“minhaFunc.sci");
x = 0:0.1:2*%pi;
plotaPontos(sin,x);
plotaPontos(minhaFunc,x);
22
DCC001 2013-1
23
DCC001 2013-1


Uma função é normalmente escrita em um arquivo
separado do arquivo com o programa principal
O arquivo com a função deve ter
◦ o mesmo nome da função
◦ a extensão

.sci (um programa tem a extensão .sce)
Para “incorporar” uma função ao Scilab, use
exec(<nome do arquivo com a função>) no
programa cliente
24
DCC001 2013-1
25
DCC001 2013-1
exec("fatorial.sci")
n=input("n="); k=input("k=");
nComb = fatorial(n)/...
fatorial(n-k)*fatorial(k)


O Scilab só toma conhecimento da existência
de uma função através do comando exec
O arquivo com a função deve estar no mesmo
diretório do programa que chama a função
26
DCC001 2013-1
27
DCC001 2013-1
Técnica: chamada da função antes de
seu desenvolvimento
 O programador deve especificar o
resultado desejado da função,
postergando o trabalho de determinar
como obter este resultado

28
DCC001 2013-1

Sabendo que o conjunto de números
primos é infinito,
◦ Construir um programa que lê uma série de
números e, para cada número lido, encontra o
menor primo que seja maior ou igual a ele
◦ Se, por exemplo, o número lido for 4, o
programa deve encontrar o número primo 5; se
for 11, o programa deve encontrar o próprio 11.
◦ O programa deve terminar quando o número
lido for menor ou igual a 1
29
DCC001 2013-1

Programa principal
◦ Cuida da interação com o usuário
◦ O problema de encontrar o menor primo ≥ n é
“empurrado” para uma função
n = input("n = ");
while n >= 2
// Encontra o menor primo >= n
// e imprime o resultado
printf("O menor primo >= %d é %d",...
n,menorPrimoMaiorOuIgual(n))
// Lê n
n = input("n = (use n < 2 se quiser parar):");
end
30 DCC001 2013-1

Função MenorPrimoMaiorOuIgual
◦ Loop de procura por um primo
◦ Não interage com o usuário
◦ Empurra o problema de saber se um número é primo
para outra função
function p = menorPrimoMaiorOuIgual(n)
p = n;
while ~primo(p)
p = p+1
end
endfunction
31
DCC001 2013-1

Função Primo
◦ Testa se um número é primo
◦ A saída é booleana: %t se for primo, %f senão
◦ Usa a função MenorFator(q) que calcula o menor
divisor de q diferente de 1
function ehPrimo = primo(k)
ehPrimo = (k == menorFator(k));
endfunction
32
DCC001 2013-1

Função MenorFator
◦ Encontra o menor fator de um número
◦ Usa a função modulo, que é fornecida pelo Scilab
function f = menorFator(q)
f = 2;
while modulo(q,f) ~= 0
f = f + 1;
end
endfunction
33
DCC001 2013-1



Funções são uma ferramenta muito útil de
modularização
Seu uso permite o reaproveitamento de código e o
encapsulamento de detalhes
O uso de funções permite o desenvolvimento
gradual de programas por refinamentos sucessivos
34
DCC001 2013-1
Escreva um programa que faça a
leitura de n valores.
Para cada valor x lido, o programa
deve calcular o valor f(x), onde f é a
função definida como f(x) = x – sqrt(x).
Os valores f(a) calculados devem ser
acumulados em um somatório.
Ao final, o programa imprime o valor
do somatório calculado.
35
Introdução
function f = myF(x)
f = x - sqrt(x);
endfunction
n = input("QUANTIDADE DE LEITURAS: ");
soma = 0;
for i = 1:n
x = input("DIGITE UM VALOR: ");
soma = soma + myF(x);
end
printf("\nSOMATÓRIO CALCULADO: %7.3f",
soma);
36
Introdução
Codifique um programa que calcule a série a seguir, onde
n é o número de parcelas.
Cada parcela contém um numerador e um denominador. O
Cálculo de ambos deve ser feito por funções definidas pelo
usuário.
Ao final o programa imprime o valor da série.
37
Introdução
function res = numerador(x)
res = x - sin(x);
endfunction
// -------------------------------------------------------------------------------------------------------
function res = denominador(x)
res = x^3 - cos(2 * x);
endfunction
// ---------------------------------------------------------------------------------------------
n = input("QUANTIDADE DE PARCELAS: ");
soma = 0;
for i = 1:n
soma = soma + numerador(i) / ...
denominador(i);
end
printf("\nSOMATÓRIO CALCULADO: %7.3f", soma);
38