Successfully reported this slideshow.
Your SlideShare is downloading. ×

Conceito de funçao e modularizaçao

Ad
Ad
Ad
Ad
Ad
Ad
Ad
Ad
Ad
Ad
Ad
Loading in …3
×

Check these out next

1 of 43 Ad
Advertisement

More Related Content

Recently uploaded (20)

Advertisement

Conceito de funçao e modularizaçao

  1. 1. 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
  2. 2. Conceitos de função e modularização
  3. 3. 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
  4. 4. Exemplo Dado três inteiros crie um algoritmo para retornar o menor deles USE APENAS (SE-ENTAO)
  5. 5. 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
  6. 6. 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
  7. 7. 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
  8. 8. 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
  9. 9. 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)
  10. 10. 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
  11. 11. 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
  12. 12. Pontos importantes: variáveis Declare x x ← 1 teste() IMPRIME x FUNCAO teste() Declare x x ← 2; DEVOLVE x
  13. 13. Pontos importantes: variáveis 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
  14. 14. Pontos importantes: variáveis Declare x x ← 1 teste(x) IMPRIME x FUNCAO teste(x) x ← x+1 DEVOLVE x
  15. 15. 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)
  16. 16. 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 SE R = “maior” ENTAO x ← x + 2 SENAO x ← x - 2 IMPRIME “é x?” LE R SE R = “correcto” FIM SE R = “maior” ENTAO x ← x + 1 SENAO x ← x - 1 IMPRIME “EU sei que é x !!!!” Crie uma função chamada chuteCerteiro para diminuir a repetição de código
  17. 17. DECLARE x x ← 8 x ← chuteCerteiro(x, 4) x ← chuteCerteiro(x, 2) x ← chuteCerteiro(x, 1) IMPRIME “EU sei que é x !!!!” 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
  18. 18. Programa Principal DECLARE x x ← chuteCerteiro(8, 4) x ← chuteCerteiro(x, 2) x ← chuteCerteiro(x, 1) IMPRIME “EU sei que é x !!!!” 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
  19. 19. 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
  20. 20. 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. 21. 21 Modularização de Programas 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. 22. 22 Modularização de Programas 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; } #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: "); scanf("%d", &Idade); } exibe_dados ( ) { printf("n"); printf("Nome: %sn", Nome); printf("Idade: %dn", Idade);
  23. 23. 23 Modularização de Programas 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; } #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. 24. 24 Modularização de Programas Programas na Linguagem C - Sub-rotinas / Módulos e Variáveis: #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: "); scanf("%d", &Idade); } exibe_dados ( ) { printf("n"); printf("Nome: %sn", Nome); printf("Idade: %dn", Idade); printf("n"); } main( ) { le_nome(); le_idade(); exibe_dados(); }
  25. 25. 25 Modularização de Programas 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. 26. 26 Modularização de Programas Programas na Linguagem C - Sub-rotinas / Módulos e Variáveis: #include <stdio.h> #include <stdlib.h> char Nome[30]; le_nome ( ) { printf("Digite seu nome: "); scanf("%s", Nome); } le_idade( ) { int idade; printf("Digite sua idade: "); scanf("%d", &idade); } exibe_dados ( ) { printf("n"); printf("Nome: %sn", Nome); printf("Idade: %dn", Idade); printf("n"); } Variável Global main( ) { le_nome(); le_idade(); exibe_dados(); }
  27. 27. 27 Modularização de Programas Programas na Linguagem C - Sub-rotinas / Módulos e Variáveis: #include <stdio.h> #include <stdlib.h> char Nome[30]; le_nome ( ) { printf("Digite seu nome: "); scanf("%s", Nome); } le_idade( ) { int idade; printf("Digite sua idade: "); scanf("%d", &idade); } exibe_dados ( ) { printf("n"); printf("Nome: %sn", Nome); printf("Idade: %dn", Idade); printf("n"); } Variável Global Variável Local de Le_Idade() Cuidado: Idade agora é local main( ) { le_nome(); le_idade(); exibe_dados(); }
  28. 28. 28 Modularização de Programas 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. 29. 29 Modularização de Programas 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. 30. 30 Modularização de Programas 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); Media = calcula_media (Nota1, Nota2, Nota3); prinf (“ Media = %lf n”, Media); }
  31. 31. 31 Modularização de Programas Programas Seqüenciais e Programas Modulares: double calcula_media (N1, N2, N3) double N1, N2, N3; { return ( ( N1 + N2 + N3 ) / 3.0 ); } faz_media ( ) { 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); }
  32. 32. 32 Modularização de Programas Programas Seqüenciais e Programas Modulares: double calcula_media (N1, N2, N3) double N1, N2, N3; { return ( ( N1 + N2 + N3 ) / 3.0 ); } faz_media ( ) { 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); } main ( ) { int cont, total=10; for (cont = 0; cont < total; cont ++) faz_media ( ); }
  33. 33. 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. 34. 34 Programando uma SUB-ROTINA 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. 35. 35 Programando uma SUB-ROTINA 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. 36. 36 Programando uma SUB-ROTINA Sub-Rotinas na Linguagem “C” : Procedures * 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. 37. 37 Programando uma SUB-ROTINA Sub-Rotinas na Linguagem “C” : Procedures * 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. 38. 38 Modularização de Programas 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. 39. 39 Modularização de Programas 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. 40. 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. 41. 41 Modularidade: Procedimentos e Funções 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. 42. 42 Modularidade: Procedimentos e Funções 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. 43. 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; }

×