8. Funções e Procedimentos em C Programação Modular

Transcrição

1 8. Funções e Procedimentos em C Programação Modular Unesp Campus de Guaratinguetá Curso: Programação de Computadores Prof. Aníbal Tavares Profa. Cassilda Ribeiro 1 8. Funções e Procedimentos - Definições Para a estruturação de programas, utiliza-se o conceito de MODULARIZAÇÃO. Modularizar um programa consiste em dividi-lo em partes que serão desenvolvidas em separado. Essas partes executam tarefas menores que depois serão acopladas para formar o programa. A cada uma dessas partes chamamos de subprograma. Os subprogramas permitem uma melhor legibilidade e manutenibilidade do programa 2

2 8. Funções e Procedimentos - Definições A forma de modularizar um programa em C é através de Funções e Procedimentos. Pode-se então dizer que : Funções e Procedimentos são blocos de código que podem ser nomeados e chamados de dentro de um programa. Programas grandes e complexos devem ser construídos bloco a bloco Funções e Procedimentos - Definições Utilidade de funções: Um função pode ser empregada para evitar repetição de código e assim facilitar a manutenção do código contido no programa. Na linguagem C, de modo geral, as Funções e Procedimentos são chamadas dentro da Função Principal ( ) ou ainda por outras funções. A declaração da função deve vir antes de seu uso. 4

3 8. Funções e Procedimentos - Definições A declaração de uma Função em C é constituída de um cabeçalho e de um corpo. O cabeçalho identifica a Função através de um nome, e o corpo contém as declarações dos objetos locais, além de comandos e estruturas do procedimento. Uma função no C tem a seguinte forma geral: tipo_de_retorno nome_função ( parâmetros ) declarações comandos Corpo da Função 5 O tipo-de-retorno é o tipo de valor que a função vai retornar. O default é o tipo int, ou seja, uma função para qual não declaramos o tipo de retorno é considerada como retornando um inteiro. A declaração de parâmetros é uma lista de variáveis com a seguinte forma geral: 8. Funções e Procedimentos - Definições tipo nome1, tipo nome2,..., tipo nomen Repare que o tipo deve ser especificado para cada uma das N variáveis de entrada. É na declaração de parâmetros que informamos ao compilador quais serão as entradas da função (assim como informamos a saída no tipo-de-retorno). 6

4 8. Funções e Procedimentos - Definições Uma função pode retornar qualquer valor válido em C, sejam de tipos pré-definidos ( int, char, float) ou de tipos definidos pelo usuário ( struct, typedef ) Um Procedimento é função que não retorna nada. Ela é definida colocando-se o tipo void como valor retornado. Pode-se colocar void entre parênteses se a função não recebe nenhum parâmetro O corpo da função é a sua alma. É nele que as entradas são processadas, saídas são geradas ou outras coisas são feitas Funções e Procedimentos - Declaração de Funções O cabeçalho de uma função NUNCA deve ser seguido de ponto e virgula. Dentro do corpo de uma função pode-se escrever qualquer instrução ou conjunto de instruções da linguagem C. Em C não se pode definir funções dentro de funções. A comunicação entre a função e o programa principal (main) se faz através dos argumentos que são enviados a ela e dos parâmetros presentes na função 8

5 8. Funções e Procedimentos - Declaração de Funções É o programa principal que controla o fluxo de execução do programa como um todo. Quando o programa principal chama a função; através do seu nome; o controle do fluxo de execução do programa passa para a função. No momento que termina a execução da função o controle do fluxo de execução retorna para o programa principal Funções e Procedimentos - Utilização de Funções Exemplo 8.1: Fazer um programa que imprima a seguinte saída na tela: ======= Para fazer este programa sem a utilização do conceito de modularidade, isto é, sem usar funções, é necessário fazer um laço para imprimir cada uma das linhas. Os dois programas mostrados a seguir resolvem este problema sem função e com função. 10

6 8.1 Funçõ ções e Procedimentos: Utilização de Funções Exemplo 8.1 Sem usar Função int i; // Imprime linha com 3 +. for (i=0; i < 3; i++) printf( + ); printf( \n ); // Imprime linha com 5 +. for (i=0; i < 5; i++) printf( + ); printf ( \n ); // Imprime linha com 7 =. for (i=0; i < 7; i++) printf( = ); printf ( \n ); Continuação... // Imprime linha com 5 +. for (i=0; i < 5; i++) printf( + ); printf ( \n ); // Imprime linha com 3 +. for (i=0; i < 3; i++) printf( + ); printf( \n ); Observe que foi necessário repetir duas vezes o for para imprimir 3+ e duas vezes o for para imprimir Funçõ ções e Procedimentos: Utilização de Funções Exemplo 8.1 com Função void imprime_linha_3 () int i; for(i=0;i < 3; i++) printf( + ); printf ( \n ); void imprimelinha_5() int i; for(i=0; i < 5; i++) printf( + ); printf ( \n ); void imprimelinha_7() int i; for(i=0; i < 7; i++) printf( = ); printf ( \n ); imprimelinha_3(); chamadas imprimelinha_5(); imprimelinha_7(); das funções imprimelinha_5(); no main. imprimelinha_3(); Observe que: 1. com o uso de funções, não é preciso repetir os comandos for. 2. O que se repete são as chamadas das funções 3. As funções são chamadas dentro do main. 4. As funções utilizadas não tem parâmetros de entrada nem de saída. 5. O void serve para indicar que a função não tem parâmetro de saída. 12

7 8.1 Funçõ ções e Procedimentos: Utilização de parâmetros. O programa do Exemplo 8.1 pode ser aperfeiçoado se forem utilizados parâmetros de entrada. Pode-se então fazer uma função mais genérica, por exemplo, a função imprimech. Nos parâmetros são passados: o caractere que será utilizado na função e o numero de linhas n, que serão impressas. Exemplo 8.2 Com parâmetros void imprimech(char ch, int n) int i; for(i=0;i < n; i++) printf( %c,ch); printf( \n ); imprimech( +,3); imprimech( +,5); imprimech( =,7); imprimech( +,5); imprimech( +,3); chamada das funções com argumentos Funçõ ções e Procedimentos: Utilização de parâmetros. Relembrando: a comunicação entre a função e o programa principal (main) é feita através dos argumentos e dos parâmetros. Na declaração da função é necessário definir o tipo de cada parâmetro. Os argumentos da função tem que ser compatíveis com os tipos declarados nos parâmetros. 14

8 8.1 Funçõ ções e Procedimentos: Utilização de parâmetros. No exemplo 8.2, os parâmetros passados no cabeçalho da função são: void imprimech(char ch, int n). Os argumentos são colocados na chamada da função imprimech( +,3); O primeiro parâmetro é a variável ch do tipo char, e ele é compatível com o primeiro argumento + segundo parâmetro é a variável n do tipo int e ele é compatível com o numero 3. Relembrando: Uma função que não retorna nada (void ) é um procedimento. Logo o exemplo 8.1 é um procedimento Funçõ ções e Procedimentos: Utilização de parâmetros. Exemplo 8.3: Fazer um programa para verificar se um dado número é par ou não. Para isso, utilize uma função com passagens de parâmetros. #include <stdlib.h> int verifpar(int k) if (k%2 == 0) return 1; else return 0; int num, resultado; printf("digite um numero "); scanf("%d",&num); resultado = verifpar(num); if(resultado == 1) printf("\no numero que voce digitou eh par\n"); else A função verifpar retorna um numero inteiro. É por esta razão que foi colocado o int antes do nome da função. O número é retornado através do comando return. printf("\no numero que voce digitou nao eh par\n"); system("pause"); O numero retornado é armazenado na variável resultado 16

9 8.1 Funçõ ções e Procedimentos: Utilização de parâmetros. Observações sobre o exemplo 8.3 É passado para a função int verifpar(int k) uma variável (k) do inteiro. A função recebe esta variável, verifica se ela é par ou não e devolve ao programa principal o numero 1 se k for par e o numero zero se k for impar. A função utiliza o comando return para devolver o valor. O tipo do valor devolvido é que define o tipo da função. A função int verifpar(int k) é então uma função do tipo inteiro, porque o valor devolvido é inteiro. O programa principal armazena o valor recebido na variável resultado Funçõ ções e Procedimentos: Conceitos Importantes Variáveis Locais : são variáveis declaradas dentro de um subprograma. Elas só podem ser manipuladas dentro do subprograma que as declarou. Logo, elas não são visíveis em nenhuma outra parte do programa. No Exemplo 8.4 mostrado a seguir, a variável a é uma variável local e qualquer alteração que se faça nela, dentro da função mudaa, não será visível dentro do programa principal, main( ). 18

10 8.2 Funçõ ções e Procedimentos: Variável Local Exemplo 8.4 Variável Local Função mudaa(). void mudaa() int a; a = 4; printf( MudaA, a = %d \n,a); Função Principal. int a; a = 2; printf( main, a = %d \n,a); mudaa(); printf( main, a = %d \n,a); Na tela main, a = 2 Na tela mudaa, a = 4 Na tela main, a = 2 Observe que o valor da variável a foi alterado em mudaa(), mas esta alteração não foi repassada para ao main Funçõ ções e Procedimentos: Variável Local Na realidade a variável a da função mudaa() não é igual a variável a do main. O programa trabalha com as duas variáveis independentemente. Com a variável local, duas funções diferentes, por exemplo f1 e f2 podem ter o mesmo nome de variável, para armazenar dados diferentes, pois neste caso quando a função f1 está sendo executada o valor da variável fica oculto em f2 e vice versa. 20

11 8.1 Funçõ ções e Procedimentos: Variável Global Variáveis globais: são variáveis declaradas no início do programa principal (no corpo do main). As variáveis globais podem ser manipuladas durante toda a execução do programa, Assim qualquer alteração que se faça numa variável global irá refletir em todas as funções do programa. Cuidado, pois ao se definir uma variável global, ela não poderá ser redeclarada em outra função do programa, porque isto acarreta um erro de compilação A seguir é mostrado um exemplo utilizando variável global Funçõ ções e Procedimentos: Variável Global Exemplo 8.5 Variável Global int a; Função mudaa(). void mudaa() a = 4; printf( MudaA, a = %d \n,a); Função Principal. a = 2; printf( main, a = %d \n,a); mudaa(); printf( main, a = %d \n,a); Observe que a variável a foi declarada no corpo do programa principal e não dentro da função mudaa, como no exemplo anterior Quando uma variável é declarada no corpo do main, ela não pode ser declarada dentro da função. 22

12 8.2 Funçõ ções e Procedimentos: Variável Global Exemplo 8.5 Escopo Global int a; Função mudaa(). void mudaa() a = 4; printf( MudaA, a = %d \n,a); Função Principal. a = 2; printf( main, a = %d \n,a); mudaa(); printf( main, a = %d \n,a); Na tela main, a = 2 Na tela mudaa, a = 4 Na tela main, a = 4 O valor da variável a foi alterado em mudaa() e esta alteração foi passada para a variável a do. Mas,deve-se evitar o uso de variáveis globais Funçõ ções e Procedimentos: Escopo Local e Global Os conceitos de variáveis globais e locais determinam um termo denominado ESCOPO. Variáveis que possuem Escopo Global são acessadas por todos as subprogramas que estão contidos em um programa. Variáveis que possuem Escopo Local são acessadas somente por subprogramas que estão contidos no subprograma. Depois de terminada a execução de uma função (procedimento), todas as suas variáveis locais são destruídas. 24

13 8.2 Funçõ ções e Procedimentos: Instruçã ção Return Funções que retornam um valor Na linguagem C existem varias funções que já estão programadas, como por exemplo a função sqrt(x ) que calcula a raiz quadrada de x, a função sin(x) que calcula o seno(x) etc. Um função pode ser responsável por fazer uma determinada tarefa e uma vez terminada esta tarefa, ela devolve, como resultado, apenas um valor. A devolução do resultado é feita através do comando return, seguido do valor a ser devolvido. Após o comando return pode ser colocado qualquer expressão válida em C Funçõ ções e Procedimentos: Instruçã ção o Return Exemplo 8.6 Return Função mudaa(). int mudaa(int b) b = b*b; printf( MudaA, a = %d \n,b); return b; Função Principal. int a; a = 2; printf( main, a = %d \n,a); a = mudaa(a); printf( main, a = %d \n,a); Tipo de retorno Tipo de Parâmetro Valor a retornar A variável a recebe o resultado da função mudaa(a) (a). 26

14 8.2 Funçõ ções e Procedimentos: Instruçã ção o Return Exemplo 8.6 Return Função mudaa(). int mudaa(int b) b = b*b; printf( MudaA, a = %d \n,b); return b; Função Principal. int a; a = 2; printf( main, a = %d \n,a); a = mudaa(a); printf( main, a = %d \n,a); Observe que aqui estamos utilizando variáveis locais, O valor de a foi alterado em mudaa(), e o novo valor de a foi repassado para através do return. Na tela main, a = 4 Na tela MudaA, a = 4 Na tela main, a = Funçõ ções e Procedimentos: Instruçã ção Return Uma função pode conter várias instruções return, mas apenas uma instrução return é executada. A devolução do resultado é feita através do comando return, seguido do valor a ser devolvido. Após o comando return pode ser colocado qualquer expressão válida em C A instrução return termina a execução da função (procedimento), e o controle do programa é devolvido ao local onde a função (procedimento) foi invocada. 28

15 8.2 Funçõ ções e Procedimentos: Instruçã ção Return Exemplo 8.7 Fazer um programa que solicite ao usuário dois números e apresente na tela o resultado da sua soma e do dobro de cada um deles. Utilize uma função para calcular a soma e outra para o dobro. #include <stdlib.h> // Função que devolve a soma de dois inteiros int soma (int a, int b) return a+b ; // Função que devolve o dobro de qualquer inteiro int dobro (int x) return 2*x ; // Função principal chama as demais. int n, i, total; printf( Introd. dois numeros ); scanf( %d%d,&n,&i); total=soma(n,i); printf( %d+%d=%d\n,n,i,total); printf( 2*%d=%d e 2*%d=%d\n,n,dobro(n), i, dobro(i)); Funçõ ções e Procedimentos: Instruçã ção Return OBS: Uma vez que a função dobro devolve um inteiro o seu resultado pode ser usado dentro de um printf, sendo escrito com o formato de inteiro (%d) Ao executar este programa teremos na tela o seguinte: Introd dois numeros: =11 2*4=8 e 2*7=14 Uma função pode ser invocada dentro de uma outra função. O resultado é o mesmo que se obteria se, em vez da chamada a função aí estivesse o resultado devolvido a esta. 30

16 8.2 Funçõ ções e Procedimentos: Instruçã ção Return Exemplo 8.8 Qual seria a saída se acrescentássemos ao programa anterior a seguinte linha: printf( %d,dobro(soma(dobro(2), 3))); solução: dobro(2) 4 soma(dobro(2), 3)) soma(4, 3)) 7 dobro(soma(dobro(2), 3))) dobro(soma(4,3)) dobro(7) 14 Então o valor impresso na tela seria 14. Isto é equivalente a colocar no programa anterior as seguintes linhas: a= dobro(2); b= soma(a, 3)); c= dobro(b); printf( %d,c); Funçõ ções e Procedimentos: Escopo/Vetores Exemplo 8.9 Vetores. Fazer um programa, com duas funções sendo que a primeira deve gerar um vetor V com elementos aleatórios num dado intervalo [a,b] e a segunda deve imprimir os elementos do vetor. #include <stdlib.h> #include <time.h> // Função que atribui elementos // aleatórios para v em [a,b]. void gerav(int v[], int n, int a, int b) int i; srand(time(0)); for (i=0; i < n; i++) v[i] = (rand()%(b-a+1))+a; // Função que imprime um vetor. void imprimev(int v[], int n) int i; for(i=0; i < n; i++) printf(" [%2d] ",v[i]); printf("\n"); // Função principal chama as demais. int v[10]; // Gera vetor com valores em [a,b]. gerav(v,10,1,6); imprimev(v,10); 32

17 8.2 Funçõ ções e Procedimentos: Escopo/Vetores OBSERVAÇÕES sobre o Exemplo 8.9 Vetores 1) Quando a função main chama o procedimento gerav, através da linha: gerav(v,10,1,6); é passado para o procedimento o valor de n=10 e o intervalo a= 1 e b= 6. 2) O procedimento gerav gera os elementos do vetor v e o devolve para o main. Isto é feito sem usar o comando return. O novo valor de v é utilizado em. 3) O valor de v retorna para a função main, pois no caso de vetores é passada a referência e não os valores (isto será melhor entendido com o estudo de ponteiros.) 4) Se a variável v não fosse um vetor ela não retornaria para a função main. Para que ela retornasse seria necessário usar o return e não teríamos um procedimento e sim uma função Funçõ ções e Procedimentos: Escopo/Vetores Exemplo 8.10 Bubble Sort #include <stdlib.h> // Usa o Bubble Sort Aperfeiçoado. void ordenavetor(float v[], int n ) int i,j; float tmp; for (i=0; i < n-1; i++) for (j=0; j < n-i-1;j++) if (v[j] > v[j+1]) tmp = v[j]; v[j] = v[j+1]; v[j+1] = tmp; // Função Principal. float Vetor[60]; int n, i, j; printf( No. elementos de v: "); scanf("%d",&n); printf("digite elementos de v:"); for (i=0; i < n; i++) scanf("%f",&vetor[i]); ordenavetor(vetor, n); printf("vetor Ordenado\n"); for (i=0; i < n; i++) printf("%.1f\n",vetor[i]); system("pause"); 34

18 8.2 Funçõ ções e Procedimentos: Escopo/Vetores OBSERVAÇÕES sobre Exemplo 8.10 Bubble Sort 1) Neste exemplo o vetor v é lido na função main e a seguir é passado para o procedimento ordenavetor através da linha: ordenavetor(vetor, n); 2) O procedimento ordenavetor, ordena os elementos do vetor e o devolve para o main. Isto é feito sem usar o comando return, pois trata-se de um vetor. 3) A seguir o main, imprime o vetor ordenado. 4) Observe também que dentro do procedimento o vetor tem o nome de v e dentro do main o nome é vetor Funçõ ções e Procedimentos: Escopo/Matrizes Exemplo 8.11 Matrizes #include <stdlib.h> #include <time.h> const int m = 5; const int n = 4; // Gera matriz com elementos em [a,b]. void geram(int A[][n], int a, int b) int i, j; srand(time(0)); for (i=0; i < m; i++) for (j=0; j < n; j++) A[i][j] = (rand()%(b-a+1))+a; // Imprime matriz. void printm(int A[][n]) int i, j; for (i=0; i < m; i++) for (j=0; j < n; j++) printf("[%2d]",a[i][j]); printf("\n"); // Função Principal. int i, j; int A[m][n]; geram(a,1,6); printm(a); 36

19 8.2 Funçõ ções e Procedimentos: Escopo/Matrizes OBSERVAÇÕES sobre o Exemplo Matrizes 1) Neste exemplo a matriz A é gerada aleatoriamente no procedimento geram. 2) O procedimento geram, devolve os elementos de A para o main. Isto é feito através das linhas: a) void geram(int A[][n], int a, int b) b) geram(a,1,6); Observe que: a linha (a) é o cabeçalho do procedimento geram e nele estão declaradas: a matriz A (int A[][n]), a variável inteira a (int a) e a variável inteira b (int b). No caso da declaração da matriz é necessário estipular somente o número de colunas, que neste caso é n. A linha (b) é a chamada do procedimento dentro do main e as variáveis que estão dentro do parêntese tem uma correspondência 37 direta com as variáveis do cabeçalho. 8.2 Funçõ ções e Procedimentos: Escopo/Matrizes 3) A seguir o main, envia os elementos de A para o procedimento printm que o imprime. Isto é feito através das linhas: void printm(int A[][n]), printm(a); que são respectivamente, cabeçalho do procedimento e chamada do procedimento dentro do main. 4) Observe também que tudo isto é feito sem usar o comando return. 5) O return só pode ser usado quando se quer devolver um único valor. 38

20 8.3 Funçõ ções e Procedimentos: Protótipos tipos Foi visto que na linguagem C a declaração da função deve ser colocada antes do ponto onde ela é chamada. Por esta razão, até agora, sempre escrevemos as funções antes da função principal main (). Para grandes projetos isto não é prático e algumas vezes é inviável determinar qual função deve preceder as demais. Este problema pode ser contornado com a utilização de protótipos. O protótipo de uma função consiste na repetição da linha de sua definição (cabeçalho) seguida do caractere (;). O protótipo da função deve então ser colocado antes desta ser chamada. Vejamos o exemplo 8.12 a seguir: Funçõ ções e Procedimentos: Protótipos tipos //programa que lê um número e imprime seu fatorial #include <stdlib.h> //Função que calcula e imprimi o fatorial void fat (int n) int i; int f = 1; for (i = 1; i <= n; i++) f *= i; printf("fatorial = %d\n", f); /* Função principal */ main () int n; scanf("%d", &n); fat(n); system("pause"); Exemplo 8.12 A função está colocada antes do local onde ela é chamada 40

21 8.3 Funçõ ções e Procedimentos: Protótipos tipos A utilização de protótipo permite que a função seja colocada em qualquer parte do programa, inclusive depois da função main. Os protótipos servem para indicar ao compilador quais são os parâmetros de entrada e saída da função sem ser necessário detalhar sua implementação. Reescrevendo o exemplo anterior utilizando protótipo: Funçõ ções e Procedimentos: Protótipos tipos //programa que lê um numero e imprime seu fatorial #include <stdlib.h> void fat (int n); /* Função principal */ main () int n; scanf("%d", &n); fat(n); system("pause"); //Função que calcula e imprimi o fatorial void fat (int n) int i; int f = 1; for (i = 1; i <= n; i++) f *= i; printf("fatorial = %d\n", f); Protótipo da Função fat Chamada da Função fat A função está colocada depois do local onde ela é chamada, porque está sendo usado protótipo 42

22 8.3 Funçõ ções e Procedimentos: Protótipos tipos Exemplo 8.13: Função que imprime um vetor Cabeçalho e corpo da função Chamada da função dentro da função main. #include <stdlib.h> // Função que imprime um vetor. void imprimev(int v[], int n) int i; for(i=0; i < n; i++) printf(" [%2d] ",v[i]); printf("\n"); // Função principal chama imprimev. int v[10] = 0; // Imprime elementos do vetor. imprimev(v,10); Funçõ ções e Procedimentos: Protótipos tipos Refazendo o exemplo 8.13 com Protótipo Protótipo da função Chamada da função Declaração e corpo da função #include <stdlib.h> void imprimev(int v[], int n); // Função principal chama imprimev. int v[10] = 0; // Imprime elementos do vetor. imprimev(v,10); // Função que imprime um vetor. void imprimev(int v[], int n) int i; for(i=0; i < n; i++) printf(" [%2d] ",v[i]); printf("\n"); 44

23 8.3 Funçõ ções e Procedimentos: Protótipos tipos Exemplo 8.14 Ping-Pong #include <stdlib.h> #include <time.h> void ping(int a, int b, int val1, int cont); void pong(int a, int b, int val2, int cont); // Função ping. void ping(int a, int b, int val1, int cont) int val2 = (rand()%(b-a+1))+a; printf( Ping: %d \n,val2); if (val2 > val1) cont++; if (cont!= 4) pong(a,b,val2,cont); else printf( Ping ganhou: %d! \n,cont); // Função pong. void pong(int a, int b, int val2, int cont) int val1 = (rand()%(b-a+1))+a; printf( Pong: %d \n,val1); if (val1 > val2) cont--; if (cont!= 0) ping(a,b,val1,cont); else printf( Pong ganhou:%d! \n,cont); // Função Principal. srand(time(0)); ping(0,4,2,2); Funçõ ções e Procedimentos: Protótipos tipos Observe que no exemplo anterior o programa não teria como ser compilado sem o uso de protótipos, pois a função ping pode chamar pong e pong pode chamar ping. ping pong Ou seja, em qualquer ordem que sejam colocadas as funções ping e pong, sempre uma delas estará indefinida em relação a outra. O uso de protótipos não é uma opção e sim uma necessidade neste caso. 46

24 8.4 Funçõ Exemplo 8.15 Pilha de Execução #include <stdlib.h> #include <math.h> int f1(int x) return (x/3); int f2(int x) return ((cos(x)*cos(x))/(1-sin(x))); O programa ao lado equivale a resolver a expressão: y=(cos(x/3)*cos(x/3))/(1-sin(x/3)) f1 f1 f1 int a, b; a = f1(2); b = f2(a); printf( b = f2(f1(2)) = %d \n, b); f2 b Funçõ Exemplo 8.15 Pilha de Execução #include <stdlib.h> #include <math.h> int f1(int x) return (x/3); A forma como isto é feito é melhor explicado com o conceito de pilha de execução: Início a=f1(2) int f2(int x) return ((cos(x)*cos(x))/(1-sin(x))); int a, b; a = f1(2); b = f2(a); printf( b = f2(f1(2)) = %d \n, b); printf(b) b=f2(a) Fim 48

25 8.4 Funçõ Definição função recursiva: Exemplos funções recursivas: Uma função é denominada recursiva se ela chama a si mesma. Toda função recursiva é estabelecida a partir de uma relação de recorrência que é calculada usando: (i) O cálculo do n-ésimo termo de uma função a partir de termos menores que n. (ii) Um caso base ao qual é associado um valor. Fatorial Fat(n) = n*fat(n-1) Fat(0) = 1 Fibonacci F(n) = F(n-1)+F(n-2) F(0) = F(1) = Funçõ Exemplo 8.16 Fatorial recursiva #include <stdlib.h> int fat(int n) int resp; if (n == 0) return 1; else resp = n*fat(n-1); return resp; // Função Principal. int n; printf( Entre com n >= 0: ); scanf( %d,&n); printf( Fatorial(n) = %d \n,fat(n)); Caso base Fat(n) = 0 Fat(n) = n*fat(n-1) Chamada recursiva 50

26 8.4 Funçõ Fatorial: n = 3 int fat(int n = 3) int resp; if (n == 0) return 1; else resp = 3*fat(2); return resp; int fat(int n=2) int resp; if (n == 0) return 1; else resp = 2*fat(1); return resp; Obtido o valor do caso base, a expressão de cada chamada pode ser resolvida do caso base até o caso n. A recursão cria chamadas a uma mesma função até que o caso base seja obtido. int fat(int n=1) int resp; if (n == 0) return 1; else resp = 1*fat(0); return resp; int fat(int n=0) int resp; if (n == 0) return 1; else resp = n*fat(n-1); return resp; Funçõ Exemplo 8.16 Fatorial Recursiva Usando pilha de execução: #include <stdlib.h> int fat(int n) int resp; if (n == 0) return 1; else resp = n*fat(n-1); return resp; // Função Principal. int n; printf( Entre com n >= 0: ); scanf( %d,&n); printf( Fatorial(n) = %d \n,fat(n)); 0! = 1 1! = 1*0! 2! = 2*1! 3! = 3*2! fat(0)! = 1 fat(1) = 1*fat(0) fat(2) = 2*fat(1) fat(3) = 3*fat(2) 52

27 8.4 Funçõ Exemplo 8.17 Fatorial com Laço #include <stdlib.h> int fat(int n) int resp = n; if (n == 0) resp = 1; else for (i=n-1; i >= 1; i--) resp = resp*i; return resp; // Função Principal. int n; printf( Entre com n >= 0: ); scanf( %d,&n); printf( Fatorial(n) = %d \n,fat(n)); Caso base Fat(n) = 0 Fat(n) = n*fat(n-1) Chamada recursiva Funçõ Exemplo 8.17 Fatorial com Laço #include <stdlib.h> int fat(int n) int i, resp = n; if (n == 0) resp = 1; else for (i=n-1; i >= 1; i--) resp = resp*i; return resp; // Função Principal. int n; printf( Entre com n >= 0: ); scanf( %d,&n); printf( Fatorial(n) = %d \n,fat(n)); Observação importante: Para toda função recursiva existe uma função equivalente que utiliza laço e fornece a mesma solução. Porém, a função com recursão sempre fornece um código mais simples e nem sempre é trivial encontrar o laço que equivale a recursão (vide Exemplo 8.18: Fibonacci e Exemplo 8.19: O problema da Torre de Hanói). 54

28 8.4 Funçõ Exemplo 8.18 Fibonacci #include <stdlib.h> int Fib(int n) int resp; if (n == 0 n == 1) resp = 1; else resp = Fib(n-1)+Fib(n-2); return resp; int n; printf( Entre com n >= 0: ); scanf( %d,&n); printf( Fibonacci(n) = %d \n,fib(n)); system( pause ); Casos base F(1) = F(0) = 0 F(n) = F(n-1)+F(n-2) Chamada recursiva Funçõ Uma outra forma de representar as sucessivas chamadas a uma função recursiva é utilizar uma árvore de recursão: F(2) F(2) = F(1)+F(0) F(3) F(3) = F(2)+F(1) Nível 3 Nível 2 F(1) F(1) = 1 F(1) F(1) = 1 Nível 1 F(0) F(0) = 1 Nível 0 56

29 8.4 Funçõ O problema da Torre de Hanói consiste em transportar todos os discos do pino 1 para o pino 3 e mover um disco por vez e sem colocar um disco maior sobre um menor A resolução deste problema utilizando recursão é: (i) Mover n-1 discos de 1 para 2. (ii) Mover o n-ésimo disco de 1 para 3. (iii) Mover n-1 discos de 2 para Funçõ A resolução deste problema utilizando recursão é: (i) Mover n-1 discos de 1 para 2. (ii) Mover o n-ésimo disco de 1 para 3. (iii) Mover n-1 discos de 2 para 3. 58

30 8.4 Funçõ A resolução deste problema utilizando recursão é: (i) Mover n-1 discos de 1 para 2. (ii) Mover o n-ésimo disco de 1 para 3. (iii) Mover n-1 discos de 2 para Funçõ A resolução deste problema utilizando recursão é: (i) Mover n-1 discos de 1 para 2. (ii) Mover o n-ésimo disco de 1 para 3. (iii) Mover n-1 discos de 2 para 3. 60

31 8.4 Funçõ A resolução deste problema utilizando recursão é: (i) Mover n-1 discos de 1 para 2. (ii) Mover o n-ésimo disco de 1 para 3. (iii) Mover n-1 discos de 2 para Funçõ Exemplo 8.19 Torre de Hanói #include <stdlib.h> int mover(int n, char a, char b, char c) if (n > 0) mover(n-1,a,c,b); printf( %c -> %c \n,a,b); mover(n-1,c,b,a); // Função Principal. int n; printf( Entre com n: ); scanf( %d,&n); printf( Solucao Hanoi %d discos\n,n); mover(n, A, C, B ); 62

32 8.4 Funçõ Para n = 3, temos: (i) Mover(2,A,B,C) (ii) Mover(1,A,C,B) (iii) Mover(2,B,C,A) (i) Mover(2,A,B,C) (i.1) Mover(1,A,C,B): A->C (i.2) A->B (i.3) Mover(1,C,B,A): C->B A B C A B C A B C A B C Funçõ Para n = 3, temos: (i) Mover(2,A,B,C) (ii) Mover(1,A,C,B) (iii) Mover(2,B,C,A) (ii) Mover(1,A,C,B): A->C A B C A B C 64

33 8.4 Funçõ Para n = 3, temos: (i) Mover(2,A,B,C) (ii) Mover(1,A,C,B) (iii) Mover(2,B,C,A) (iii) Mover(2,A,B,C) (iii.1) Mover(1,B,A,C): B->A (iii.2) B->C (iii.3) Mover(1,A,C,B): A->C A B C A B C A B C A B C Funçõ Nível 3 Nível 2 Nível 1 Mover(3, A, C, B ) Mover(2, A, B, C ) Mover(1, A, C, B ) A -> C A -> B Mover(1, C, B, A ) C -> B A -> C Mover(2, B, C, A ) Mover(1, B, A, C ) B -> A B -> C Mover(1, A, C, B ) A -> C 66

34 8.4 Funçõ Fim de Funções e Procedimentos Programação Modular Aplicaçõ ções Problema 1: Construir um programa que simule um jogo da velha. O programa deve cumprir os seguintes requisitos: (i) Permitir movimentos alternados de dois jogadores A e B. (ii) Identificar se um movimento pode ser realizado ou não. (iii) Identificar o término de um jogo, indicando as 3 possíveis situações: (1) A ganhou, (2) B ganhou, (3) Empate. (iv) Construir um tabuleiro que permita a representação das jogadas tal como dado abaixo. Jogada de A x.. Espaço livre Jogada de B. o

35 8. Funções O Problema do Caminho Mínimo Os nós do grafo, apresentados abaixo, representam cidades, e os arcos, a presença de uma estrada ligando duas cidades. Os números ao lado dos arcos representam a distância medida em quilômetros Funções O Problema do Caminho Mínimo Pode-se representar este grafo através de uma variável composta bidimensional D, na qual a existência de conexão entre duas cidades i e j é indicada pelo elemento D[ i, j ] diferente de zero. Desta forma tem-se: Matriz D de distância entre as cidades 70

36 8. Funções O Problema do Caminho Mínimo O problema consiste, então em achar o caminho mais curto entre duas cidades quaisquer. Este problema foi resolvido por Dijkstra (1971) e tem uma série de aplicações na resolução de problemas de otimização. Para resolvê-lo; atribui-se rótulos as cidades, contendo as seguintes informações: 1. Distância acumulada da origem até a cidade C, DA[C]; 2. Um apontador indicando qual a cidade antecessora de C, PAI[C]; 3. Um indicador do estado de C, ESTADO[ C ], que pode ser expandida, não-expandida, não-rotulada Funções O Problema do Caminho Mínimo Partindo da origem, determinam-se as cidades adjacentes (aquelas que tem um caminho em comum) a ela. Estas cidades são rotuladas da seguinte forma: DA[ cidade adjacente ] DA[ origem ] + D[ origem,cidade adjacente ] PAI[ cidade adjacente ] origem ESTADO[ cidade adjacente ] Não expandida A cidade geradora da expansão, no caso a origem, tem seu estado alterado: ESTADO[ origem ] expandida Escolhe-se a seguir, a cidade não expandida cuja distância acumulada seja menor. Repete-se o processo anterior, determinando-se e rotulando-se as cidades adjacentes a escolhida. 72

37 8. Funções O Problema do Caminho Mínimo Na hipótese de que uma cidade adjacente já esteja rotulada não expandida, um teste se faz necessário com vistas a comparação da distância acumulada dos dois caminhos, prevalecendo aquele de menor distância acumulada. Garante-se que as cidades rotuladas expandidas já foram alcançadas pelo caminho mais curto da origem até ela. Este procedimento é repetido até que o destino seja rotulado ou até que não existirem cidades rotuladas não expandidas Funções O Problema do Caminho Mínimo #include <stdlib.h> //Programa principal int PAI [100], C, ORIGEM, DESTINO, i, j,n,k; float D[100][100], DA[100], MIN; int ESTADO[100]; // Leitura da matriz de distância printf("digite o numero de cidades \n"); scanf("%d",&n); for (i=1;i<=n;i++) for (j=1;j<=n;j++) printf("digite a distancia entre a cidade %d e %d ",i,j); scanf("%f",&d[i][j]); //impressao matriz de distancia printf("a matriz de distancia lida eh \n"); for (i=1;i<=n;i++) for (j=1;j<=n;j++) printf("%4.f", D[i][j]); printf("\n"); printf("\n"); // Inicialização de ESTADO for (i=0; i<=n;i=i+1) ESTADO[i]=0;// 0=nao rotulada, //1=não expandida, 2= expandida. // Ler nó) origem e nó destino printf("digite o no. da cidade de origem \n"); scanf("%d",&origem); printf("digite o no. da cidade de destino \n"); scanf("%d",&destino); 74

38 8. Funções O Problema do Caminho Mínimo //Rotular origem C = ORIGEM; PAI[C] = 0; DA[C] = 0.0; k=1; while (( C!= DESTINO) && (C!= 0)) //rotular cidades adjacentes for (i=1;i <= N;i++ ) if((estado[i]== 1) && (D[C][i]!= 0) ) if (DA[i] > DA[C] + D[C][i]) PAI[i] = C; DA[i] = DA[C] + D[C][i]; else if(( D[C][i]!= 0 ) && (ESTADO[i] == 0)) ESTADO[i] = 1; //nao expandido PAI[i] = C; DA[i] = DA[C] + D[C][i]; ESTADO [C] = 2; //Expandido //Escolha de um novo C MIN = ; for(j=1;j<= N;j++) //inicio if(estado[j]== 1)// não expandido / if(da[j] < MIN) //então MIN=DA[j]; C=j; //fim então //fim for j if (MIN == ) C = 0; //fim while rotular cidades adjacentes Funções O Problema do Caminho Mínimo if(c == 0) printf(" Nao existe Caminho unindo"); printf(" as cidades %d e %d\n", ORIGEM, DESTINO); else printf("\n Caminho mais curto ente %d e %d eh:\n",origem, DESTINO); while(c!= ORIGEM) printf("%d ",C); C = PAI[C]; printf("%d ",ORIGEM); printf("\n A distancia eh %.2f:\n",DA[DESTINO]); system("pause"); 76

39 8. Funções O Problema do Caminho Mínimo 77