Conceito de funçao e modularizaçao

Responsável
Prof. Seiji Isotani (sisotani@icmc.usp.br)
Aula 6
Conceitos de Função e
modularização
Departamento de Sistemas de Computação
Universidade de São Paulo
Introdução a Ciência de Computação I

Conceitos de
função e
modularização

Você já percebeu que:
• À medida que aumenta o tamanho de um
programa fica mais difícil de gerenciar
• As vezes existem muitas repetições no
código e que trechos do programa podem
ser reutilizados em diferentes lugares
• É possível testar partes do programa em
separado
• As vezes conseguimos resolver parte do
problemas, mas não ele todo

Exemplo
Dado três inteiros crie um
algoritmo para retornar o
menor deles
USE APENAS (SE-ENTAO)

Resposta
LEIA n1, n2, n3
SE (n1 <= n2) ENTAO
SE (n1 <= n3) ENTAO
IMPRIME n1
SENAO
IMPRIME n3
SENAO // n1 > n2
SE (n2 <= n3) ENTAO
IMPRIME n2
SENAO
IMPRIME n3

Resposta
LEIA n1, n2, n3
SE n1 <= n2 ENTAO
imprimeMenor(n1, n3)
SENAO
imprimeMenor(n2, n3)
FUNCAO imprimeMenor(x, y)
SE x <= y ENTAO
IMPRIME x
SENAO
IMPRIME y

Resposta
LEIA n1, n2, n3, menor
SE n1 <= n2 ENTAO
menor ← imprimeMenor(n1, n3)
IMPRIME menor
SENAO
menor ← imprimeMenor(n2, n3)
IMPRIME menor
FUNCAO imprimeMenor(x, y)
SE x <= y ENTAO
DEVOLVE x
SENAO
DEVOLVE y

Exemplo:
• Para modularizar o código utiliza-se o
conceito de função (ou procedimento)
• Uma função é um conjunto de
instruções com entradas e saídas bem
definidas
– Nome
– Entradas
– Instruções que executam a tarefa
– Instruções que devolvem o resultado
(saídas)

Definição
/********* Comentário **********
- O que a função faz?
- Quais as entradas
- Quais as saídas
*******************************/
FUNCAO nomeDaFuncao(parâmetro1, parâmetro2, ...)
DECLARE variável1, variáveln
instrução1
instruçãon
.......
Devolve variáveln;
Variáveis locais
Acessíveis somente
dentro da função
Valor de retorno
corpo
argumentos

Vantagens das funções
• Modularização
– Permite dividir de forma lógica partes do
código
– Facilita a reutilização
– ajuda a lidar com a complexidade
– facilita a divisão de trabalho
• Encapsulamento
– Esconde o que não precisa ser
apresentado

Pontos importantes: variáveis
Declare x
x ← 1
teste()
IMPRIME x
FUNCAO teste()
Declare x
x ← 2;
DEVOLVE x

Declare x
x ← 1
x ← teste()
IMPRIME x
FUNCAO teste()
Declare x
x ← 2
PARA i ← 0 ate 1 FACA
x ← x + i
DEVOLVE x

Declare x
x ← 1
teste(x)
IMPRIME x
FUNCAO teste(x)
x ← x+1
DEVOLVE x

Exercício
Crie um programa que consegue
adivinhar um número no raio de 1 a 15
em no máximo 4 tentativas
(assuma que o jogador diga se o número
é maior ou menor a cada tentativa
incorreta).
USE APENAS (SE-ENTAO)

DECLARE X, R
X = 8
IMPRIME “é x?”
LE R
SE R = “correcto” FIM
SE R = “maior” ENTAO x ← x + 4 SENAO x ← x - 4
IMPRIME “é x?”
LE R
SE R = “correto” FIM
IMPRIME “é x?”
LE R
SE R = “correcto” FIM
IMPRIME “EU sei que é x !!!!”
Crie uma função
chamada chuteCerteiro
para diminuir a
repetição de código

DECLARE x
x ← 8
x ← chuteCerteiro(x, 4)
FUNCAO chuteCerteiro(x, y)
DECLARE R
IMPRIME “é x?”
LE R
SE R = “correcto” IMPRIME “ACERTEIIIII ☺” FIM
SE R = “maior” ENTAO
DEVOLVE x + y
SENAO
DEVOLVE x - y

Programa Principal
DECLARE x
x ← chuteCerteiro(8, 4)
Declaração da Função
FUNCAO chuteCerteiro(x, y)
DECLARE R
IMPRIME “é x?”
LE R
SE R = “correto” FIM
SE R = “maior” ENTAO
Devolve x + y
SENAO
Devolve x – y

Exercício 1
• Escreve um algoritmo que calcula a
soma de 4 números:
n1
e1
+ n2
e2
+ n1
e3
+ n2
e4
• Depois verificar se a soma resultante é
par ou impar.
Dica: escreva uma função chamada
POTENCIA que recebe dois números, a base
“b” e o expoente “e” e calcula o valor da
potência be

Programando funções em C
Exemplo: Criar funções para ler, nome, idade e exigir
esses dados na tela
20
Modularização de Programas

21
Quebrando programas na Linguagem C - Sub-rotinas / Módulos:
#include <stdio.h>
#include <stdlib.h>
char Nome[30];
int Idade;
main( )
{
printf("Digite seu nome: ");
scanf("%s", Nome);
printf("Digite sua idade: ");
scanf("%d", &Idade);
printf("n");
printf("Nome: %sn", Nome);
printf("Idade: %dn", Idade);
printf("n");
system("PAUSE");
return 0;
}

22
#include <stdio.h>
#include <stdlib.h>
char Nome[30];
int Idade;
main( )
{
scanf("%s", Nome);
printf("n");
printf("n");
system("PAUSE");
return 0;
}
#include <stdio.h>
#include <stdlib.h>
char Nome[30];
int Idade;
le_nome ( )
{ printf("Digite seu nome: ");
scanf("%s", Nome);
}
le_idade( )
{ printf("Digite sua idade:
");
}
exibe_dados ( )
{ printf("n");
printf("Idade: %dn",
Idade);

23
#include <stdio.h>
#include <stdlib.h>
char Nome[30];
int Idade;
main( )
{
scanf("%s", Nome);
printf("n");
printf("n");
system("PAUSE");
return 0;
}
#include <stdio.h>
#include <stdlib.h>
char Nome[30];
int Idade;
le_nome ( )
{ ... }
le_idade( )
{ ... }
exibe_dados ( )
{ ... }
main( )
{
le_nome();
le_idade();
exibe_dados();
system("PAUSE");
return 0;
}

24
Programas na Linguagem C - Sub-rotinas / Módulos e Variáveis:
#include <stdio.h>
#include <stdlib.h>
char Nome[30];
int Idade;
le_nome ( )
scanf("%s", Nome);
}
le_idade( )
{ printf("Digite sua idade: ");
}
exibe_dados ( )
{ printf("n");
printf("n");
}
main( )
{
le_nome();
le_idade();
exibe_dados();
}

25
Sub-Rotinas e Variáveis
• Programas podem ter variáveis gerais, as denominadas
variáveis globais que podem ser usadas por qualquer
sub-rotina. Todos módulos tem acesso as variáveis globais.
• Variáveis globais são declarada FORA dos blocos, ou seja,
fora das sub-rotinas.
• Programas podem ter variáveis proprietárias de um bloco,
as denominadas variáveis locais que podem ser usadas
apenas dentro da sub-rotina (bloco) onde foram criadas.
Variáveis locais são acessadas somente dentro do seu bloco.

26
#include <stdio.h>
#include <stdlib.h>
char Nome[30];
le_nome ( )
scanf("%s", Nome);
}
le_idade( )
{
int idade;
scanf("%d", &idade);
}
exibe_dados ( )
{ printf("n");
printf("n");
}
Variável
Global
main( )
{
le_nome();
le_idade();
exibe_dados();
}

27
#include <stdio.h>
#include <stdlib.h>
char Nome[30];
le_nome ( )
scanf("%s", Nome);
}
le_idade( )
{
int idade;
scanf("%d", &idade);
}
exibe_dados ( )
{ printf("n");
printf("n");
}
Variável
Global
Variável
Local de
Le_Idade()
Cuidado: Idade
agora é local
main( )
{
le_nome();
le_idade();
exibe_dados();
}

28
Funções e Procedimentos da Linguagem C - Sub-rotinas:
Você já usa sub-rotinas !
Sub-Rotinas da Biblioteca Padão do “C” (Libc). Exemplos:
printf (“Hello!n”); => Executa uma sub-rotina de impressão na tela
scanf (“%d”,valor); => Executa uma sub-rotina de entrada de dados
strcpy (Nome,”Fulano”); => Copia uma string para uma variável
num = atoi (“1234”); => Converte uma string em valor inteiro
preco = atof (“56.78”); => Converte uma string em valor float/double
x = sqrt (nro); => Extrai a raiz quadrada de um número
x = sin (angulo); => Calcula o seno dado um determinado ângulo
sorteio = rand ( ) % 10; => Gera um número pseudo-aleatório de 0 a 9
getchar ( ); => Espera que seja pressionada uma tecla

29
Sub-rotinas( ) e seus Blocos {} :
main ( ) => Main é um bloco que recebeu o nome especial “main”
{
printf(“1”); => Printf é uma sub-rotina executada pelo main
getchar ( ); => Getchar é uma sub-rotina executada pelo main
printf(“2”); => Sub-rotinas podem ser usadas (chamadas) diversa vezes!
getchar ( );
}
getchar ( ) => Getchar é um bloco que recebeu um nome
{ ... } Sub-Rotina: Getchar / Sem Parâmetros
strcpy (Dest, Org) => Strcpy é um bloco que recebeu um nome
{ ... } Sub-Rotina: Strcpy / Com Parâmetros

30
Programas Seqüenciais e Programas Modulares:
double calcula_media (N1, N2, N3)
double N1, N2, N3;
{
return ( ( N1 + N2 + N3 ) / 3.0 );
}
main ( )
{ double Nota1, Nota2, Nota3; double Media;
scanf (“%lf”,&Nota1); scanf (“%lf”,&Nota2); scanf (“%lf”,&Nota3);
Media = calcula_media (Nota1, Nota2, Nota3);
prinf (“ Media = %lf n”, Media);
scanf (“%lf”,&Nota1); scanf (“%lf”,&Nota2); scanf (“%lf”,&Nota3);
}

31
double N1, N2, N3;
{
return ( ( N1 + N2 + N3 ) / 3.0 );
}
faz_media ( )
{
double Nota1, Nota2, Nota3;
double Media;
scanf (“%lf”,&Nota1);
}

32
double N1, N2, N3;
{
return ( ( N1 + N2 + N3 ) / 3.0 );
}
faz_media ( )
{
double Nota1, Nota2, Nota3;
double Media;
}
main ( )
{
int cont, total=10;
for (cont = 0; cont < total; cont ++)
faz_media ( );
}

33
Programando uma SUB-ROTINA
SUB-ROTINA ou PROCEDURE: Declaração, Definição e Parâmetros
[tipo] nome_da_rotina ( <nome_vars_parâmetros> ){
<variáveis_locais>;
<comandos>;
}

34
SUB-ROTINA ou PROCEDURE: Declaração, Definição e Parâmetros
void calc_media (double, double); /*declara a sub-rotina*/
void calc_media (double v1, double v2){
double media;
media = (v1 + v2 ) / 2.0;
printf("Media=%.2lf",media);
}
[tipo] nome_da_rotina ( <nome_vars_parâmetros> ){
<variáveis_locais>;
<comandos>;
}

35
Sub-Rotinas na Linguagem “C” : Procedures
* Exemplos de sub-rotinas : passagem de parâmetros por valor
void exibe_media ( v1, v2 ) /* Rotina: exibe_media */
int v1, v2; /* Entrada: v1, v2 - inteiros */
{ /* Passagem de params. por valor */
double media; /* v1 e v2 recebem uma cópia de n1 e n2 */
media = ( v1 + v2 ) / 2.0;
printf (“Média = %lf n”, media); /* Exibe o resultado na tela */
v1 = v2 = 0; /* Zera v1 e v2... Não afeta n1, n2 */
}
main ( )
{
int n1, n2;
printf (“Entre 2 números inteiros: “);
scanf (“%d %d”,&n1, &n2);
exibe_media ( n1, n2 ); /* Chama a procedure media */
}
By Value

36
* Exemplos de sub-rotinas : passagem de parâmetros por valor
void exibe_media ( int v1, int v2 ) /* Rotina: exibe_media
{ /* Entrada: v1, v2 - inteiros */
/* Passagem de params. por valor */
double media; /* v1 e v2 recebem uma cópia de n1 e n2 */
media = ( v1 + v2 ) / 2.0;
printf (“Média = %lf n”, media); /* Exibe o resultado na tela */
v1 = v2 = 0; /* Zera v1 e v2... Não afeta n1, n2 */
}
main ( ) {
int n1, n2;
printf (“Entre 2 números inteiros: “);
scanf (“%d %d”,&n1, &n2);
exibe_media ( n1, n2 ); /* Chama a procedure media */
}
By Value

37
* Exemplos de sub-rotinas :
Passagem de parâmetros POR VALOR
- Passagem de parâmetros deve respeitar o tipo de cada parâmetro !
- Passagem de parâmetros deve respeitar a ordem dos parâmetros !
- Passagem de parâmetros deve cuidar a quantidade de parâmetros !
- É passada apenas uma cópia dos parâmetros originais...
(exceto quando são passados ponteiros/endereços)
By Value

38
Variáveis em Programas Modulares:
VARIÁVEIS GLOBAIS [aloc. estática]
São variáveis declaradas fora de qualquer bloco {} do programa,
usualmente declaradas no início do código fora do main().
São acessíveis por em qualquer parte do programa: uso livre.
VARIÁVEIS LOCAIS [aloc. dinâmica]
São variáveis declaradas dentro de um bloco {} do programa,
podendo ser variáveis locais do main(), de um procedimento,
de uma função, ou mesmo de um bloco de um dado comando.
São acessíveis somente dentro do bloco onde estão declaradas: uso limitado.
VARIÁVEIS DO TIPO PARÂMETRO (By Value) [aloc. dinâmica]
São variáveis de parâmetro de uma função ou procedimento (“cópias”).
São acessíveis só dentro da sub-rotina onde estão declaradas: uso limitado.

39
Entrada e Saída de Parâmetros em Procedures e Functions...
- Não existe uma limitação maior no número de parâmetros de entrada;
- Passagem de parâmetros BY VALUE passa a cópia do dado, ou seja,
se o dado passado for alterado, isto não irá afetar o dado original;
- Functions podem retornar apenas um valor.
Entrada e Saída de Parâmetros sem restrições...
Aguarde: Parâmetros BY REFERENCE
>>>> NA PRÓXIMA SEMANA !!! <<<<

40
Modularidade: Procedimentos e Funções
Exercícios
Ex. 1
Considere o programa
ao lado e responda as
perguntas que seguem...
Faça um
“Teste de Mesa”
(Simulação da Execução)
Enumere quais são as
variáveis deste programa:
Globais
Locais
Parâmetros
1 double calcula_media (int v1, int v2 )
2 {
3 double media;
4 media = ( v1 + v2 ) / 2.0;
5 v1 = v2 = 0;
6 return (media);
7 }
8 int main ( )
9 {
10 int n1, n2;
11 double m1, m2;
12 printf (“Entre 2 números inteiros: “);
13 scanf (“%d %d”,&n1, &n2);
14 m1 = calcula_media ( n1, n2 );
15 m2 = calcula_media ( 10, 7 );
16 return 0;
17 }

41
Exercícios
1) Enumere a seqüência de passos que foram executados pelo programa.
Use a numeração ao lado do código para descrever a seqüência de
comandos que foram executados.
A execução começa por: 9, 10, 11, 12, 13 ...
2) Enumere em que pontos do programa podem ocorrer erros referentes
aos parâmetros (detalhar os tipos de erro que podem ser cometidos)
3) Faça um teste de mesa e indique o valor das variáveis abaixo quando
for executada cada uma das linhas de comando indicadas abaixo:
Linha 16 – Valor de m1? Linha 16 – Valor de media?
Linha 17 – Valor de m2? Linha 17 – Valor de v1 e v2?
(Supor que o usuário digitou: 5 e 6) Linha 6 - Valor de n1 e n2?

42
Exercícios Ex.2
Faça um programa que tenha um laço para ler as notas dos 10 alunos
e calcule as médias destes alunos. Do aluno 1 ao 5 a média usa pesos
iguais para ambas provas, e do aluno 6 ao 10 a prova P2 tem peso dobrado.
DICA:
Faça um programa com 2 sub-rotinas: le_notas, calc_media.
A sub-rotina le_notas recebe como parâmetro de entrada o número
de um aluno (os alunos são numerados de 1 a 10), realiza a leitura
das notas deste aluno (notas P1 e P2) e chama uma outra sub-rotina
que realize o cálculo da média.
A sub-rotina calc_media recebe como parâmetro as duas notas do aluno
e calcula uma média ponderada das 2 notas. Os pesos de cada prova
também são passados como parâmetros. A sub-rotina devolve o valor
da média ponderada calculada.

43
Faça o teste de mesa:
1 float calc_mediaP(float V1,float V2)
2 {
3 float mediaP;
4 mediaP = ((V1 + V2)/2)*0.7;
5 return (mediaP);
6 }
7 float calc_mediap(float v1,float v2)
8 {
9 float mediap;
10 mediap = ((v1 + v2)/2)*0.3;
11 return (mediaP);
12 }
13 float calc_mediaF(float V,float v)
14 {
15 float mediaFinal;
16 mediaFinal = V + v;
17 return (mediaFinal);
18 }
19 char calc_conceitoF(float media)
20 {
21 char conceito;
22 if (media > 5)
23 conceito = ‘A’;
24 else
25 conceito = ‘R’;
26 return (conceito);
27 }
28 int main (){
29 float P1, P2, p1, p2, M, m, MF;
30 char conc;
31 printf(“Entre com P1 e P2:”);
32 scanf(“%f %f”, &P1, &P2);
33 M = calc_mediaP(P1, P2);
34 printf(“Entre com p1 e p2:”);
35 scanf(“%f %f”, &p1, &p2);
36 m = calc_mediap(p1, p2);
37 MF = calc_mediaF(M, m);
38 conc = calc_conceito(MF)
39 printf(“Media final: %f”, MF);
40 printf(“nConceito: %c”, conc);
41 return 0;
}

Conceito de funçao e modularizaçao

Recommandé

Recommandé

Contenu connexe

Similaire à Conceito de funçao e modularizaçao

Similaire à Conceito de funçao e modularizaçao (20)

Conceito de funçao e modularizaçao