Linguagem C LPG – I - FUNÇÕES Prof. Flavio Marcello

Apresentação em tema: "Linguagem C LPG – I - FUNÇÕES Prof. Flavio Marcello"— Transcrição da apresentação:

1 Linguagem C LPG – I - FUNÇÕES Prof. Flavio Marcello

2 Funções Um SubPrograma, é um nome dado a um trecho de um programa mais complexo e que, em geral, encerra em si próprio um pedaço da solução de um problema maior (o programa a que ele está subordinado). São sinônimos: Procedimento, Função, Módulo (estrutura modular), Métodos (orientação a objetos) e Subrotina; e são conceitos da ciência conhecida como engenharia de software.

3 Funções Em geral: Problemas complexos = programas complexos Um problema complexo é melhor abordado se for dividido em vários subproblemas, as funções. Programa complexo = Função1 + Função FunçãoN

4 Estrutura de uma Função
A “sintaxe” para definição de funções é dividida em duas partes: (1) cabeçalho e (2) corpo <tipo> <nome> ([ <parâmetros> ]) cabeçalho, ou assinatura, ou interface { <corpo, ou instruções> }

5 Estrutura de uma Função
tipo: tipo de dado que define o valor de retorno nome: identificador, ou nome atribuído a função parâmetros: lista opcional de parâmetros (dados de entrada) corpo: conjunto de instruções que representam o corpo da função

6 (1) Cabeçalho, ou assinatura, ou interface de funções
<tipo> <nome> ([ <parâmetros> ]) Descreve: (1) o tipo do valor retornado pela função; (2) o nome ou identificador através do qual é realizada a chamada da função; e (3) lista de parâmetros, ou dados de entrada void parada(void) void tabuada(int n) int ehPrimo(int n) float GEB(char sexo, int pc, int alt, int i)

7 (2) Corpo ou Bloco de Instruções
Define o conjunto de instruções que serão executadas quando a função for chamada ou invocada O corpo de uma função é delimitado pelos elementos sintáticos de bloco “{” e “}” void tabuada(int n) { // início do corpo da função, ou módulo 'Tabuada' for (int i=1; i<=10; i++) printf("%2d * %d = %d\n", i, n, (i*n)); printf("Pressione [] para prosseguir.");getch(); } // fim do corpo da função 'Tabuada'

8 Escopo de Variáveis O escopo de uma variável ou sua abrangência está vinculada a sua visibilidade, Global ou Local, em relação aos subprogramas de um programa. Variável Global: pode ser usada por “todas” as funções implementadas a partir da declaração da variável (geralmente declaradas acima da função main). Variável Local: pode ser usada “somente” no local em que foi declarada, ou seja, pela própria função (declaradas no corpo da função).

9 Chamando ou Invocando Funções
Uma função, ou módulo, somente é executada quando o seu nome é chamado dentro da função main() ou por outra função (ou subprograma) que esteja em execução = módulo chamador. O nome de uma função é um identificador pelo qual ela será referênciada numa sentença de chamada (ou invocação, ou ativação) = módulo chamado. Ao término do corpo da função o controle de execução é devolvido ao “módulo chamador”.

10 Escopo de Variáveis O uso de variáveis globais dentro da função serve para implementar um mecanismo de transmissão de informações de um nível mais externo para um mais interno. A utilização de variáveis globais não constitui, no entanto, uma boa prática de programação (escopo muito grande). Assim, toda função ao ser implementada deve utilizar variáveis locais, e a transmissão de informações para dentro e fora das funções deve ser feita através dos parâmetros de transmissão. Nota: As variáveis locais são criadas e alocadas quando da ativação e automaticamente liberadas quando do seu término.

11 #include "stdio.h" #include "conio.h" // declaração das Variáveis Globais: podem ser usadas, ou // referenciadas, em “todos” os subprogramas: main e tabuada void main() { // módulo chamador: // declaração das Variáveis Locais: só poderão ser usadas, // ou referenciadas, na função ‘main’ ... } // declaração das Variáveis Globais “com escopo reduzido”: // podem ser usadas pela função tabuada e por outras // funções declarada a seguir void tabuada(int n) { // módulo chamado: // ou referenciadas, na função ‘tabuada’

12 Conflito nos “nomes” de variáveis
As variáveis locais são variáveis declaradas dentro de uma função cujos nomes são conhecidos somente para essa função. As variáveis globais, por sua vez, são conhecidas por todas as funções do programa. Em situações que o nome da variável global for igual ao nome da variável local, teremos um conflito de nomes. Quando temos um conflito de nomes,o C sempre usará a variável local.

13 Estrutura Modular A função main() é o “ponto inicial” da execução da estrutura modular, ou seja, a estrutura dividida em funções. Pode conter quantas funções forem necessárias e/ou convenientes.

14 PROTÓTIPO DE FUNÇÃO A maioria dos compiladores C precisa conhecer a “assinatura” das funções, para poder identificá-las, antes do início da execução do programa. A linguagem C permite colocar os protótipos das funções declaradas no início do programa, antes da implementação da função main(). O protótipo de uma função corresponde ao seu cabeçalho, ou assinatura: <tipo> <nome> ([ <parâmetros> ]); Dentro do Programa Principal, os SUBPROGRAMAS devem ser definidos depois da declaração das variáveis

15 #include "stdio.h" #include "conio.h" // Protótipo das funções: cabeçalho, assinatura ou interface das funções void tabuada(int n); void parada(void); // módulo chamador: void main() { int n = 0 ; while (n != 0) { clrscr(); printf("Informe o nro da tabuada, (-1) para encerrar: "); scanf("%d", &n); if (n != (-1)) tabuada(n); } // módulos chamados: tabuada e parada. void tabuada(int n) { // início do corpo da função, ou módulo 'tabuada' clrscr(); for (int i=1; i<=10; i++) printf("%2d * %d = %d\n", i, n, (i*n)); parada(); void parada(void) { // início do corpo da função, ou módulo 'parada' printf("Pressione [algo] para prosseguir."); getch(); } // fim corpo da função 'parada' invocando, ou chamando a função 'tabuada' transfere o fluxo de execução para o módulo chamado fim do corpo da função 'tabuada' retorna o fluxo de execução para o módulo chamador

16 PARÂMETROS São variáveis “opcionalmente” passadas a uma função.
Uma função pode ter zero ou mais parâmetros. Quando uma função não possui parâmetros deve-se utilizar a palavra-chave void para indicar esta situação. São definidos, ou declarados, no cabeçalho da função.

17 Tipos de Parâmetros Parâmetros Formais são os nomes simbólicos introduzidos no “cabeçalho” das funções. Dentro de uma função trabalha-se com estes nomes da mesma forma como se trabalha com variáveis locais ou globais. Parâmetros Reais, ou Efetivos (ou ainda, argumentos) são aqueles que se associam aos parâmetros formais quando da chamada, ou invocação, de uma função.

18 #include "stdio.h" int div(int numerador, int denominador); void main() { int n, d; printf("Digite o valor do numerador..: "); scanf("%d", &n); printf("Digite o valor do denominador: "); scanf("%d", &d); int resultado = div(n, d); printf("%d div %d = %d", n, d, resultado); } int div(int numerador, int denominador) { if (denominador == 0) return(0); else return(numerador / denominador); n e d- parâmetros reais, ou argumentos (valores) numerador e denominador: parâmetros formais (definição)

19 Finalidade dos parâmetros
Através da passagem de parâmetros é feita a transferência de informações entre as funções sejam: constantes, variáveis, ou expressões, ao invés de somente o valor de variáveis globais. Esta utilização formaliza a comunicação entre as funções (ou módulos, ou subprogramas). Existem dois tipos de passagem de parâmetros: Tipo Valor ou Constante (cópia) Tipo Variável ou Referência

20 Passagem de parâmetros por Valor
Os parâmetros reais (módulo chamador) são calculados e os parâmetros formais (cabeçalho da função) correspondentes recebem uma cópia dos valores resultantes A variável passada se comporta como uma variável local, ou seja, alterações nos parâmetros formais não afetam os parâmetros reais

21 //Passagem de parâmetros por valor
#include "stdio.h" int soma(int a, int b); void main() { int resultado = soma(2, 3); printf("2 + 3 = %d\n", resultado); // ou: printf("2 + 3 = %d", soma(2, 3)); } int soma(int a, int b) { return(a + b); ativa a função ativa a função

22 RETORNO DE VALOR E RECEPÇÃO DE PARÂMETROS
Na utilização de funções há quatro casos em relação ao valor de retorno e à recepção de parâmetros. Caso 1: funções que não retornam valor nem recebem parâmetros; Caso 2: Funções que recebem parâmetros e não retornam valor; Caso 3: Funções que recebem parâmetros e retornam valor; Caso 4: Funções que retornam valor sem receber parâmetros;

23 RETORNO DE VALOR E RECEPÇÃO DE PARÂMETROS
Caso 1: funções que não retornam valor nem recebem parâmetros: Obedecem ao seguinte modelo de protótipo e cabeçalho: void nome_função ([void]) { ... }

24 RETORNO DE VALOR E RECEPÇÃO DE PARÂMETROS
//Exemplo CASO 1: função que exibe 10 asteriscos #include <stdio.h> void exibe(void); // protótipo da função void main() { exibe(); // chama a função exibe() } void exibe (void) { // início da função exibe () int i; for(i = 0; i< 10; i++) printf("*");

25 RETORNO DE VALOR E RECEPÇÃO DE PARÂMETROS
Caso 2: Funções que recebem parâmetros e não retornam valor: Obedecem ao seguinte modelo de protótipo e cabeçalho: void nome_função ([parâmetros]) { ... } Na passagem de parâmetros, há dois tipos de parâmetros: Real -> é aquele utilizado na chamada a uma função. Formal-> é aquele utilizado no cabeçalho da função chamada.

26 RETORNO DE VALOR E RECEPÇÃO DE PARÂMETROS
//Exemplo CASO 2: função que exibe o quadrado de um numero #include <stdio.h> void quadrado (int); // protótipo da função quadrado () void main() { int numero = 4; quadrado(numero); // numero é o parâmetro real } void quadrado(int numero1) { // numero1 é o parâmetro formal printf("Quadrado: %d",(numero1 * numero1));

27 RETORNO DE VALOR E RECEPÇÃO DE PARÂMETROS
Caso 3: Funções que recebem parâmetros e retornam valor Obedecem ao seguinte modelo de protótipo e cabeçalho: tipo nome_função ([parâmetros]) { ... } Como há valor de retorno, utiliza-se o comando return.

28 Retornando um valor de uma função (return)
Normalmente as funções realizarão cálculos e fornecerão um valor ao módulo chamador Uma função precisa usar o comando return para definir o valor de retorno: return (ExpressãoDeRetorno); Para uma função fornecer um “resultado” ao “módulo chamador”, ela precisará usar o comando return.

29 Compreendendo o comando return
Quando encontra um comando return, C finaliza imediatamente a execução da função e transfere o fluxo de execução ao “módulo chamador” substituindo o trecho do comando que a invocou pelo resultado retornado pela função. Obs. o programa não executa quaisquer outros comandos da função após o comando return.

30 RETORNO DE VALOR E RECEPÇÃO DE PARÂMETROS
//Exemplo CASO 3: função que recebe um valor (horas) e //retorna o valor resultante de (valor_recebido * 60) #include <stdio.h> int converte (int); // protótipo da função converte void main() { int horas = 10, minutos; minutos= converte (horas); //chamada com parâmetro printf("%d minutos", minutos); } int converte(int horas1) { // início da função converte() return( horas1 * 60); //retorno de valor

31 RETORNO DE VALOR E RECEPÇÃO DE PARÂMETROS
Caso 4: Funções que retornam valor sem receber parâmetros Obedecem ao seguinte modelo de protótipo de cabeçalho: tipo nome_função ([ ]) { ... }

32 RETORNO DE VALOR E RECEPÇÃO DE PARÂMETROS
//Exemplo CASO 4: função NAO recebe valor e retorna valor p/ funcao // chamadora #include <stdio.h> int converte(); // protótipo da função converte() void main() { int retorno = converte(); // chama a função converte() if (retorno == 1) printf("Valor incorreto\n"); else printf("Valor correto\n"); }

33 RETORNO DE VALOR E RECEPÇÃO DE PARÂMETROS
int converte() { //início da função converte() int horas, minutos; printf("Digite as horas (entr 1 e 24): "); scanf("%d", &horas); if (horas<1 || horas >24) return 1; //retorna 1 em caso de erro else { minutos = horas * 60; printf("%d minutos", minutos); return 0; //retorna 0 em caso de sucesso }

34 Usando múltiplos parâmetros
Quando uma função usa mais de um parâmetro, é necessário especificar o tipo e o nome “de cada parâmetro individualmente” e separá-los por vírgula float GEB(char sexo, int pc, int alt, int i) { ... } int comparaCadeias(char s1[256], char s2[256]) int IMC(int pc, float alt)

35 + Exemplos // não recebe parâmetros void parada(void) { ... }
// recebe um parâmetro inteiro, objetivo: // verificar se ‘n’ eh um nro primo int ehPrimo(int n) // recebe quatro parâmetros: ‘sexo’ do tipo // char; ‘pc’, ‘alt’ e ‘i’ do tipo inteiro, // objetivo: calcular o Gasto Energético Basal float GEB(char sexo, int pc, int alt, int i)

36 #include "stdio.h" #include "conio.h" int ehPrimo(int n); void parada(void); void main() { int n; while (1) { clrscr(); printf("Informe um nro, (-1) para encerrar: "); scanf("%d", &n); if (n == (-1)) break; if (ehPrimo(n) == 1) // ou seja, não tem divisores printf("\nO nro informado eh primo."); else printf(“\nO nro informado não eh primo."); parada(); } int ehPrimo(int n) { int i = 2, naoTemDivisor = 1; while ((i <= (n / 2)) && (naoTemDivisor == 1)) if ((n % i) == 0) naoTemDivisor = 0; i = i + 1; return (naoTemDivisor); void parada(void) { printf("Pressione [algo] para prosseguir."); getch();

37 Parâmetros por referência
Os parâmetros reais (módulo chamador) compartilham seu espaço de memória com os parâmetros formais (cabeçalho da função). Portanto, alterações nos parâmetros formais afetam os parâmetros reais. Na realidade, a função recebe uma referência, ou o endereço da variável passada ou, em outras palavras, a própria variável.

38 Parâmetros por referência
Com esse tipo de passagem de parâmetros, a função pode alterar diretamente a variável passada (retornando valor). Para especificar a passagem por referência, deve-se usar o símbolo sintático “*” antes do nome do parâmetro formal (no cabeçalho da função) e o símbolo sintático “&” antes do nome do parâmetro real (no módulo chamador, indicando a passagem do endereço de memória da variável)

39 //Passagem de parâmetros por referência
#include "stdio.h" void soma(int a, int b, int *c); void main() { int resultado; soma(2, 3, &resultado); printf("2 + 3 = %d\n", resultado); } void soma(int a, int b, int *c) { *c = a + b; ativa a função parâmetro por referência parâmetro por valor

40 void soma(int a, int b, int *c); void main() { x = 2; y = 3;
#include "stdio.h" int x, y, z; void soma(int a, int b, int *c); void main() { x = 2; y = 3; soma(x, y, &z); printf("%d + %d = %d.", x, y, z); } void soma(int a, int b, int *c) { *c = a + b; I I) situação inicial x y z caixa do programa principal pilha de memória

41 void soma(int a, int b, int *c); void main() { x = 2; y = 3;
#include "stdio.h" int x, y, z; void soma(int a, int b, int *c); void main() { x = 2; y = 3; soma(x, y, &z); printf("%d + %d = %d.", x, y, z); } void soma(int a, int b, int *c) { *c = a + b; II II) ao fazer as atribuições 2 3 x y z caixa do programa principal pilha de memória

42 void soma(int a, int b, int *c); void main() { x = 2; y = 3;
#include "stdio.h" int x, y, z; void soma(int a, int b, int *c); void main() { x = 2; y = 3; soma(x, y, &z); printf("%d + %d = %d.", x, y, z); } void soma(int a, int b, int *c) { *c = a + b; III III) ao chamar a função soma 2 3 x y z a b c caixa do programa principal caixa da função soma pilha de memória

43 void soma(int a, int b, int *c); void main() { x = 2; y = 3;
#include "stdio.h" int x, y, z; void soma(int a, int b, int *c); void main() { x = 2; y = 3; soma(x, y, &z); printf("%d + %d = %d.", x, y, z); } void soma(int a, int b, int *c) { *c = a + b; IV IV) associação e/ou passagem de parâmetros 2 3 2 3 x y z a b c caixa do programa principal caixa da função soma pilha de memória

44 void soma(int a, int b, int *c); void main() { x = 2; y = 3;
#include "stdio.h" int x, y, z; void soma(int a, int b, int *c); void main() { x = 2; y = 3; soma(x, y, &z); printf("%d + %d = %d.", x, y, z); } void soma(int a, int b, int *c) { *c = a + b; V V) antes do final da execução da função soma 2 3 5 2 3 x y z a b c caixa do programa principal caixa da função soma pilha de memória

45 void soma(int a, int b, int *c); void main() { x = 2; y = 3;
#include "stdio.h" int x, y, z; void soma(int a, int b, int *c); void main() { x = 2; y = 3; soma(x, y, &z); printf("%d + %d = %d.", x, y, z); } void soma(int a, int b, int *c) { *c = a + b; VI VI) antes do final da execução da função main 2 3 5 x y z caixa do programa principal pilha de memória

46 + 1 Exemplo //Exemplo: passagem de parâmetros por endereco
#include <stdio.h> void somar (int*, int*); // protótipo da função somar() int main() { int valor1=10, valor2=40; printf("valor1 (antes): %d\n", valor1); //10 somar(&valor1, &valor2); // chama a função somar() printf("valor1 (depois): %d\n", valor1); //90 return 0; } void somar (int *v1 , int *v2) // definição da função somar() { int total = *v1 + *v2; printf("Adição: %d\n", total); //50 *v1=90;

47 CARACTERÍSTICAS DAS FUNÇÕES - RESUMO
Retorna um único valor Na definição da função devem ser declarados: o tipo de todos os parâmetros o tipo do valor que a função retorna todas as variáveis utilizadas internamente na função (variáveis locais) Para utilizar a função no programa principal basta colocar seu nome (identificador) e os parâmetros reais.

48 Vetores como argumentos de funções
Os vetores, ou matrizes são considerados um tipo de dado bastante grande, pois são formados por diversas variáveis. Por esta razão, a linguagem C determina ser mais eficiente existir uma única cópia do vetor na memória. Assim, os vetores quando utilizados como argumentos de funções eles são passados por referência (não são passados os valores contidos no vetor, somente o seu endereço). A função chamada usa o endereço de memória do vetor para acessar os elementos do próprio vetor da função que chama. Isto significa que as alterações que forem feitas no vetor pela função chamada afetarão o vetor original na função que chama.

49 Vetores como argumentos de funções
#include "stdio.h" float media(int lista[], int tamanho); void main() { const n = 5; int nota[n] = {10, 5, 8, 6, 6}; printf("Média das notas = %6.2f", media(nota, n)); } float media(int lista[], int tamanho) { int smNotas = 0; for (int i=0; i<tamanho; i++) smNotas = smNotas + lista[i]; return(float(smNotas)/tamanho); passagem por referência passagem por valor

50 FUNÇÕES RECURSIVAS Função recursiva é aquela que chama a si mesma.
Se uma função recursiva chamar a si mesma, então a função recentemente chamada chamará a si própria e assim por diante, infinitivamente, a menos que haja uma forma de interromper essa seqüência de chamadas.

51 FUNÇÕES RECURSIVAS Um método comum é fazer a chamada recursiva associada a um comando if. Por exemplo, a função teste(), recursiva que não retorna valor, poderia ter a seguinte estrutura: void teste(parâmetros) { comandos1; if(condição) teste (parâmetros) comandos2; } recursão (auto-delegação) Função

52 Recursividade Ex. função para calcular o fatorial de número: n! = n * (n-1)!

53 I) antes da chamada da função fat
função fatorial recursiva: n! = 1, se n = 0 = n * (n - 1)!, se n > 0 #include "stdio.h"; long fat(int n); void main() { printf("Fatorial de 2 = %ld.", fat(2)); } long fat(int n) { if (n == 0) return(1); else return(n * fat(n - 1)); I I) antes da chamada da função fat caixa do programa principal pilha de memória

54 II) após a chamada de fat(2)
função fatorial recursiva: n! = 1, se n = 0 = n * (n - 1)!, se n > 0 #include "stdio.h"; long fat(int n); void main() { printf("Fatorial de 2 = %ld.", fat(2)); } long fat(int n) { if (n == 0) return(1); else return(n * fat(n - 1)); II II) após a chamada de fat(2) 2 * fat(1) 2 fat n caixa do programa principal caixa da função fat(2) pilha de memória

55 III III) fat(2) chama fat(1) função fatorial recursiva:
n! = 1, se n = 0 = n * (n - 1)!, se n > 0 #include "stdio.h"; long fat(int n); void main() { printf("Fatorial de 2 = %ld.", fat(2)); } long fat(int n) { if (n == 0) return(1); else return(n * fat(n - 1)); III III) fat(2) chama fat(1) 2 * fat(1) 2 1 * fat(0) 1 fat n fat n caixa do programa principal caixa da função fat(2) caixa da função fat(1) pilha de memória

56 IV IV) fat(1) chama fat(0) função fatorial recursiva: n! = 1, se n = 0
= n * (n - 1)!, se n > 0 #include "stdio.h"; long fat(int n); void main() { printf("Fatorial de 2 = %ld.", fat(2)); } long fat(int n) { if (n == 0) return(1); else return(n * fat(n - 1)); IV IV) fat(1) chama fat(0) 2 * fat(1) 2 1 * fat(0) 1 1 fat n fat n fat n pilha de memória caixa do programa principal caixa da função fat(2) caixa da função fat(1) caixa da função fat(0)

57 V) fat(0) é 1- ocorre o retorno na ordem inversa
função fatorial recursiva: n! = 1, se n = 0 = n * (n - 1)!, se n > 0 #include "stdio.h"; long fat(int n); void main() { printf("Fatorial de 2 = %ld.", fat(2)); } long fat(int n) { if (n == 0) return(1); else return(n * fat(n - 1)); V V) fat(0) é 1- ocorre o retorno na ordem inversa 2 2 * fat(1) 2 2 1 * fat(0) 1 1 1 fat n fat n fat n pilha de memória caixa do programa principal caixa da função fat(2) caixa da função fat(1) caixa da função fat(0)

58 VI) antes do final da execução da função main
função fatorial recursiva: n! = 1, se n = 0 = n * (n - 1)!, se n > 0 #include "stdio.h"; long fat(int n); void main() { printf("Fatorial de 2 = %ld.", fat(2)); } long fat(int n) { if (n == 0) return(1); else return(n * fat(n - 1)); VI VI) antes do final da execução da função main 2 caixa do programa principal pilha de memória

59 Conflito nos “nomes” de variáveis
A linguagem C fornece uma extensa biblioteca de funções (p.ex. stdio.h) que podem ser usadas para chamar funções (por exemplo, printf) que executam tarefas específicas. Entretanto, o programador pode criar as suas funções e identificá-las com o mesmo nome de uma função da biblioteca. Quando o nome de uma função declarada pelo programador está em “conflito” com o nome de uma função da biblioteca usada, ao chamá-la o C usa a função mais local, ou seja, a função do programa e não a função da biblioteca.

60 Arquivos Cabeçalhos (.h)
Arquivos cabeçalhos são aqueles incluídos (#include “stdio.h”) no início dos programas em linguagem C A extensão h vem de header (cabeçalho em inglês) Arquivos cabeçalhos mais comuns: stdio.h, stdlib.h, conio.h, string.h, … Objetivo = criar uma biblioteca de SubProgramas

61 Arquivo geral.h #include "stdio.h" #include "dos.h" #include "conio.h"
void parada(int x, int y) { gotoxy(x, y); printf("Pressione [algo] para prosseguir."); getch(); } void mostraHora(int x, int y) { struct time t; gettime(&t); printf("%d:%d:%d", t.ti_hour, t.ti_min, t.ti_sec); int ehPar(int n) { return((n % 2) == 0);

62 Criando um Arquivo .h No arquivo .h “não” deve ser implementada a função main() O arquivo .h deve ser salvo na pasta include da instalação do C

63 Usando o Arquivo geral.h
#include "geral.h" void main() { for (int i=1; i<=10; i++) if (ehPar(i)) printf("O número %2d eh par.\n", i); else printf("O número %2d eh ímpar.\n", i); mostraHora(01, 12); parada(01, 14); } incluindo o arquivo cabeçalhos- geral.h chamando os subprogramas implementados no arquivo cabeçalhos- geral.h

64 Vantagens da Subprogramação
Subdivisão de programas complexos Cada parte menor tem um código mais simples Facilita o entendimento (partes independentes) Estruturação de programas Detecção de erros e documentação de sistemas modularização de sistemas Desenvolvimento por equipes de programadores Manutenção de software Reutilização de subprogramas (bibliotecas de subprogramas- arquivos .h)

65 Referência Programando em C/C++ “A Bíblia” Kris Jamsa & Lars Klander.
São Paulo: MAKRON Books

66 FUNÇÕES Obrigado LPG-I Flavio Marcello

67 FUNÇÃO – Exercício Desenvolver uma função MAIOR para determinar o maior elemento de um vetor de números inteiros. Utilizar esta função para determinar o maior elemento de uma matriz de números inteiros de dimensão M x N

68 #include <stdio.h>
#include <conio.h> #define TAM 10 //prototipo da funcao para encontrar o maior valor int MAIOR (int AUX[], int ); int main () { int W[TAM], R[TAM]; int S[TAM][TAM]; int I, J, M, N, F; printf ("FORNECA O VALOR DE Linhas: "); scanf ("%d", &M); printf ("\nFORNECA O VALOR DE Colunas: "); scanf ("%d", &N); //carrega a matriz for (I=0; I < M; I++) { printf("\n"); for (J=0; J < N; J++) { printf("Elemento S[%d][%d]: ",I,J); scanf ("%d", &S[I][J]); }

69 //imprime a matriz printf("\n\nMatriz informada:\n"); for(I=0; I < M; I++){ printf("\n\n"); for(J=0; J < N; J++) printf("\t%4i", S[I][J]); } //cria um vetor R com o maior elemento de cada uma das linhas da matriz for (I=0; I < M; I++){ for (J=0; J < N; J++) W[J]=S[I][J]; //passa as linha da matriz para o vetor W R[I]=MAIOR(W,N); //ao final de cada linha, chama a funcao MAIOR F=MAIOR(R,M); printf("\n\nMAIOR ELEMENTO DA MATRIZ: %d",F); getch(); return 0;

70 //função MAIOR int MAIOR(int AUX[], int T) { int I,M; M=AUX[0]; for (I = 1; I < T; I++) if (AUX[I] > M) M=AUX[I]; return M; }

71 FUNÇÃO- Exercício em Classe
Escrever uma função para verificar se dois vetores de N números inteiros são iguais. int COMPARA (int X[], int Y[], int T) Utilizar esta função em um programa para verificar se duas matriz (M x M) lidas possuem a mesma diagonal principal

72 Funcionamento das Funções (1/4)
Os módulos utilizam objetos (variáveis, pôr exemplo) declarados em seu corpo, mas podem também utilizar os objetos declarados nos níveis mais externos, chamados globais. O uso de variáveis globais dentro da função serve para implementar um mecanismo de transmissão de informações de um nível mais externo para um mais interno. A utilização de variáveis globais não constitui, no entanto, uma boa prática de programação (escopo muito grande). Assim, toda função ao ser implementada deve utilizar variáveis locais, e a transmissão de informações para dentro e fora das funções deve ser feita através dos parâmetros de transmissão. Nota: As variáveis locais são criadas e alocadas quando da ativação e automaticamente liberadas quando do seu término.

73 Funcionamento das Funções (2/4)
A função chamada é uma parte separada do módulo chamador, e somente é executada quando o seu nome (ou identificador) for referenciado numa sentença de chamada. A execução da função se comporta como se o trecho da função fosse copiada para o ponto onde foi invocada. Existem duas formas de chamada: a) nomeDaFunção(); b) nomeDaFunção(ListaDeParâmetrosReais); Os parâmetros reais na lista são separados por vírgula. O 1º parâmetro real é associado ao 1º parâmetro formal; O 2º parâmetro real é associado ao 2º parâmetro formal e assim por diante. Nota: A quantidade de parâmetros reais deve ser igual a quantidade de parâmetros formais. E ainda, o tipo do parâmetro real deve ser compatível ao tipo do respectivo parâmetro formal.

74 módulo chamador: printf("Índice Massa Corpórea = %d.", IMC(80, 1.77)); módulo chamado: int IMC(int pc, float alt) { return(pc / (alt * alt)); } o parâmetro real 80 é passado, ou associado, ao parâmetro formal pc (int para int) 2. o parâmetro real 1.77 é passado, ou associado, ao parâmetro formal alt (float para float) 80 / (1.77 * 1.77) = return(26) 26 26

75 Exemplos de “Chamadas” de Funções:
Funções que “não” retornam valor (void): a) mult(); // Função declarada sem parâmetros. b) mult(w, z); // w e z são parâmetros reais (de transmissão). Funções que retornam valor: // O valor retornado pelas funções é utilizado em expressões. // a variável ‘z’ recebe o valor retornado pela função ‘Mult’ a) z = mult(w, z); // avalia se o valor retornado pela função ‘ehPar’ é igual a ‘1’ b) if (ehPar(n) == 1) printf(“%d eh um nro par.”, n); else printf(“%d eh um nro ímpar.”, n);

76 Funcionamento das Funções (3/4)
A área de memória usada na execução de um programa varia dinamicamente durante a execução. A memória é representada graficamente como sendo uma pilha de caixa de variáveis. Cada uma destas caixas contém, pôr sua vez, um escaninho para cada uma das variáveis locais (ou parâmetros). Sempre que uma função é chamada, uma caixa contendo espaço para os parâmetros formais e para as variáveis locais é colocada no topo da pilha de memória. Quando o módulo principal (main) é iniciado a pilha contém uma caixa para as variáveis globais. Ao terminar a execução de uma função, sua caixa de variáveis e parâmetros é automaticamente retirada da pilha.

77 Funcionamento das Funções (4/4)
Chamadas, ou ativação de Funções: quando uma função é chamada para execução as seguintes tarefas são executadas: a) o C coloca o endereço da instrução que segue a chamada da função (chamado endereço de retorno) na pilha; b) os parâmetros da função são colocados na pilha (associação e passagem de parâmetros); c) se a função declara variáveis locais então o C aloca espaço na pilha, para que a função possa armazenar valor nas variáveis; d) transferência do fluxo de execução para a função chamada. Retorno de Funções: quando a execução da função é concluída as seguintes tarefas são executadas: a) o espaço da pilha que continha as variáveis locais e os parâmetros é descartado b) endereço de retorno é restabelecido; c) transferência do fluxo de execução o endereço de retorno (módulo chamador).

78 Em Síntese: Em Síntese:
escopo: de uma variável ou sua abrangência está vinculada a sua visibilidade: Global ou Local parâmetros: estabelecem um canal de comunicação entre os módulos. Em Síntese: Módulo Chamador . variáveis locais do módulo chamador . argumentos ou paramêtros efetivos ou reais int result; soma(5, 3, &result); printf("5 + 3 = %d.", result); printf("5 + 3 = %d.", soma(5, 3)); passagem de parâmetros tipo valor ou constante 8 passagem de parâmetro tipo variável ou referência Módulo Chamado . variáveis locais do módulo chamado . parâmetros formais 8 5 3 5 3 int soma(int a, int b) { return(a + b); } void soma(int a, int b, int *c) { *c = a + b; }