A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

Algoritmos Escher. Agenda SubProgramas; Conceitos; Exercícios.

Apresentações semelhantes


Apresentação em tema: "Algoritmos Escher. Agenda SubProgramas; Conceitos; Exercícios."— Transcrição da apresentação:

1 Algoritmos Escher

2 Agenda SubProgramas; Conceitos; Exercícios.

3 Introdução Motivação: nEvitar que os blocos do programa fiquem grandes demais e, por conseqüência, mais difíceis de entender; n Facilitar a leitura do programa; n Separar o programa em partes (blocos) que possam ser logicamente compreendidos de forma isolada.

4 Introdução Motivação: nPermitir o reaproveitamento de código já construído (por você ou por outros programadores); n Evitar que um trecho de código seja repetido várias vezes dentro de um mesmo programa; nPermitir a alteração de um trecho de código de uma forma mais rápida. Com o uso de subprogramas e normalmente é preciso alterar apenas algo dentro do próprio subprograma que se deseja.

5 Conceitos Iniciais Subprograma: nUm 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). nSã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.

6 Conceitos Iniciais Função – de forma geral: nProblemas complexos = programas complexos. nUm problema complexo é melhor abordado se for dividido em vários subproblemas, as funções. nPrograma complexo = Função1 + Função FunçãoN

7 Conceitos Iniciais Estrutura de uma Função: n A sintaxe para definição de funções é dividida em duas partes: (1) cabeçalho e (2) corpo ([ ]) cabeçalho, ou assinatura, ou interface { }

8 Conceitos Iniciais (1) Cabeçalho, ou assinatura, ou interface: ([ ]) n Descrição: (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)

9 Conceitos Iniciais (2) Corpo ou Bloco de Instruções: n Define o conjunto de instruções que serão executadas quando a função for chamada (invocada). n 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++) cout << "\n" << i << "x" << n << " = " << (i*n); cout << "\nPressione [enter] para prosseguir."; getchar(); } // fim do corpo da função 'Tabuada'

10 Funções Escopo de Variáveis: nO escopo de uma variável ou sua abrangência está vinculada a sua visibilidade, Global ou Local, em relação aos subprogramas (funções) de um programa. nVariá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- função principal. nVariável Local: pode ser usada somente no local em que foi declarada, ou seja, pela própria função, e são declaradas no corpo da função.

11 #include using namespace std; // declaração das Variáveis Globais: podem ser usadas, ou // referenciadas, em todos os subprogramas: main e tabuada 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: // declaração das Variáveis Locais: só poderão ser usadas, // ou referenciadas, na função tabuada... } Exemplo Escopo

12 Funções – Protótipos O que são Protótipos? nÉ considerada boa prática utilizar protótipos de função para todas as funções em seu programa. nUm protótipo declara o nome de função, seus parâmetros e seu tipo de retorno para o resto do programa antes da declaração real da função. nSão definidos ou declarados, no cabeçalho do programa.

13 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 #include //para cin, cout using namespace std; // Protótipo das funções: cabeçalho, assinatura ou interface das funções void tabuada(void); void parada(void); int n = 1, i; // modulo chamador: main() { while (n > 0) { cout << "Informe o nro da tabuada, (-1) para encerrar: "; cin >> n; if (n != (-1)) tabuada(); } // módulos chamados: tabuada e parada. void tabuada(void) { // início do corpo da função, ou módulo 'tabuada' cout << "\n\n"; for (i=1; i<=10; i++) cout << "\n" << i << "x" << n << " = " << (i*n); parada(); } void parada(void) { // início do corpo da função, ou módulo 'parada' cout << "\nPressione [enter] para prosseguir."; fflush (stdin); getchar(); cout<<"\n\n"; } // fim corpo da função 'parada' Exemplo Completo

14 Funções – Parâmetros O que são parâmetros? nSão variáveis opcionalmente passadas a uma função. nUma função pode ter zero ou mais parâmetros. nQuando uma função não possui parâmetros deve-se utilizar a palavra-chave void para indicar esta situação. nSão definidos, ou declarados, no cabeçalho da função.

15 Funções – Parâmetros Tipos de parâmetros: nParâ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. nParâ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.

16 n e d - parâmetros reais, ou argumentos (valores) numerador e denominador: parâmetros formais (definição) #include using namespace std; int divisao(int numerador, int denominador); int main() { int n, d, resultado; cout << "Digite o valor do numerador..: "; cin >> n; cout << "Digite o valor do denominador: "; cin >> d; resultado = divisao (n, d); cout << n << " / " << d << " = " << resultado; getchar(); getchar(); return (0); } int divisao(int numerador, int denominador) { if (denominador == 0) return(0); else return(numerador/denominador); } Exemplo Parâmetros Formais e Reais

17 Funções – Parâmetros Finalidade dos parâmetros: nAtravé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. nEsta utilização formaliza a comunicação entre as funções (ou módulos, ou subprogramas). nExistem dois tipos de passagem de parâmetros: nTipo Valor ou Constante (cópia) nTipo Variável ou Referência

18 Funções – Parâmetros Passagem de parâmetros por valor: nOs parâmetros reais (do módulo chamador) são calculados e os parâmetros formais (cabeçalho da função) correspondentes recebem uma cópia dos valores resultantes nA 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

19 ativa a função //Passagem de parâmetros por valor #include using namespace std; int soma(int a, int b); int main() { int resultado = soma(2, 3); cout << "2 + 3 = " << resultado << "\n"; // ou: cout << "2 + 3 = " << soma(2, 3) << "\n"; getchar(); return(0); } int soma(int a, int b) { return(a + b); } Exemplo passagem por valor soma(2, 3) ativa a função

20 Funções – Parâmetros Retorno de valor e recepção de parâmetros: nNa 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;

21 Funções – Parâmetros – Caso 1 Caso 1 – não recebe parârametro e não retorna valor: nObedecem ao seguinte modelo de protótipo e cabeçalho: void nome_função ([void]) {... } nO tipo void e um tipo especial, utilizado principalmente em funções. Ele e um tipo que representa o nada", ou seja, uma variável desse tipo armazena conteúdo indeterminado, e uma função desse tipo retorna um conteúdo indeterminado.

22 Funções – Parâmetros – Caso 1 //Exemplo CASO 1: função que exibe 10 asteriscos #include using namespace std; void exibe(void);// protótipo da função main() { exibe(); // chama a função exibe() getchar(); } void exibe (void) {// início da função exibe () int i; for(i = 0; i< 10; i++) cout << "*"; }

23 Funções – Parâmetros – Caso 2 Caso 2 – recebe parârametro e não retorna valor: nObedecem ao seguinte modelo de protótipo e cabeçalho: void nome_função ([parâmetros]) {... } nNa 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

24 Funções – Parâmetros – Caso 2 //Exemplo CASO 2: função que exibe o quadrado de um numero #include using namespace std; void quadrado (int); // protótipo da função quadrado () main(){ int numero = 4; quadrado(numero); // numero é o parâmetro real getchar(); } void quadrado(int numero1) { // numero1 é o parâmetro formal cout << "Quadrado: " << (numero1 * numero1); }

25 Funções – Parâmetros – Caso 3 Caso 3 – recebe parârametro e retorna valor: nObedecem ao seguinte modelo de protótipo e cabeçalho: tipo nome_função ([parâmetros]) {... return (ExpressãoDeRetornode_ tipo); } nComo há valor de retorno, utiliza-se o comando return.

26 Funções – Parâmetros Comando return: nNormalmente as funções realizarão cálculos e fornecerão um valor ao módulo chamador. nUma função precisa usar o comando return para definir o valor de retorno conforme a sintaxe: return (ExpressãoDeRetorno); nPara uma função fornecer um resultado ao módulo chamador, ela precisará usar o comando return.

27 Funções – Parâmetros Comando return: nQuando 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. nObs. o programa não executa quaisquer outros comandos da função após o comando return.

28 Funções – Parâmetros – Caso 3 //Exemplo CASO 3: função que recebe um valor (horas) e //retorna o valor resultante de (horas1 * 60) #include using namespace std; int converte (int); // protótipo da função converte int main(){ int horas = 10, min; min = converte (horas); //chamada com parâmetro cout << min << " minutos"; getchar(); return (0); } int converte(int horas1) { // início da função converte() return( horas1 * 60); //retorno de valor }

29 Funções – Parâmetros – Caso 4 Caso 4 – não recebe parârametro e retorna valor: nObedecem ao seguinte modelo de protótipo e cabeçalho: tipo nome_função ([void]) {... return (ExpressãoDeRetornode_ tipo); }

30 Funções – Parâmetros – Caso 4 //Exemplo CASO 4: função NAO recebe valor e retorna valor p/ funcao // chamadora #include using namespace std; int converte(); // protótipo da função converte() int main() { int retorno = converte(); // chama a função converte() if (retorno == 1) cout << "\nValor incorreto\n; else cout << "\nValor correto\n; getchar(); getchar(); return (0); }

31 Funções – Parâmetros – Caso 4 int converte() {//início da função converte() int horas, min; cout << "Digite as horas (entre 1 e 24): "; cin >> horas; if ((horas 24)) return 1; //retorna 1 em caso de erro else { min = horas * 60; cout << min << " minutos"; return 0; //retorna 0 em caso de sucesso }

32 Funções – Parâmetros Múltiplos Parâmetros: n 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) {... }

33 Funções – Parâmetros Mais 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) {... }

34 #include using namespace std; int ehPrimo(int); void parada(void); int main() { int n = 0; while (n != -1) { cout << "Informe um nro, (-1) para encerrar: "; cin >> n; if (n != -1) { if (ehPrimo(n) == 1) // ou seja, não tem divisores cout << "\nO nro informado eh primo."; else cout << "\nO nro informado nao eh primo."; } parada(); } return (0); } int ehPrimo(int n) { int i = 2, naoTemDivisor = 1; while ((i <= (n / 2)) && (naoTemDivisor == 1)) if ((n % i) == 0) naoTemDivisor = 0; else i++; return (naoTemDivisor); } void parada(void) { cout << "\nPressione [enter] para prosseguir."; getchar(); getchar(); } Exemplo Completo 2

35 Funções – Parâmetros - struct Passando uma struct para uma FUNÇÃO: struct RgAluno { char nome[35]; float nota1; float nota2; } Aluno = {Flavio Marcello", 7.0, 8.0}; ImprimeDados (Aluno); void ImprimeDados (struct RgAluno ficha) { cout << "\nNome do Aluno....: ", ficha.nome; cout << "\nNota 1o. Bimestre: ", ficha.nota1; cout << "\nNota 2o. Bimestre: ", ficha.nota2; }

36 Funções – Parâmetros Passagem de parâmetros por referência: nOs parâmetros reais (módulo chamador) compartilham seu espaço de memória com os parâmetros formais (cabeçalho da função). nPortanto, alterações nos parâmetros formais afetam os parâmetros reais. nNa 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.

37 Funções – Parâmetros Passagem de parâmetros por referência: nCom esse tipo de passagem de parâmetros, a função pode alterar diretamente a variável passada (retornando valor). n 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)

38 ativa a função parâmetro por valor parâmetro por referência //Passagem por referência #include using namespace std; void soma(int a, int b, int *c); int main() { int resultado; soma(2, 3, &resultado); cout << "2 + 3 = " << resultado; getchar(); return (0); } void soma(int a, int b, int *c) { *c = a + b; } Exemplo Referência

39 #include using namespace std; int x, y, z; void soma(int a, int b, int *c); int main() { x = 2; y = 3; soma(x, y, &z); cout << x " + " << y << " = " << d; return (0);} void soma(int a, int b, int *c) { *c = a + b; } xyz I) situação inicial caixa do programa principal pilha de memória I

40 #include using namespace std; int x, y, z; void soma(int a, int b, int *c); int main() { x = 2; y = 3; soma(x, y, &z); cout << x " + " << y << " = " << d; return (0);} void soma(int a, int b, int *c) { *c = a + b; } II) ao fazer as atribuições II xyz caixa do programa principal pilha de memória 23

41 #include using namespace std; int x, y, z; void soma(int a, int b, int *c); int main() { x = 2; y = 3; soma(x, y, &z); cout << x " + " << y << " = " << d; return (0);} void soma(int a, int b, int *c) { *c = a + b; } III) ao chamar a função soma III xyz caixa do programa principal pilha de memória 23 abc caixa da função soma

42 #include using namespace std; int x, y, z; void soma(int a, int b, int *c); int main() { x = 2; y = 3; soma(x, y, &z); cout << x " + " << y << " = " << d; return (0);} void soma(int a, int b, int *c) { *c = a + b; } IV) associação e/ou passagem de parâmetros IV xyz caixa do programa principal pilha de memória 23 abc caixa da função soma 23

43 #include using namespace std; int x, y, z; void soma(int a, int b, int *c); int main() { x = 2; y = 3; soma(x, y, &z); cout << x " + " << y << " = " << d; return (0);} void soma(int a, int b, int *c) { *c = a + b; } V) antes do final da execução da função soma V xyz caixa do programa principal pilha de memória 23 abc caixa da função soma 235

44 #include using namespace std; int x, y, z; void soma(int a, int b, int *c); int main() { x = 2; y = 3; soma(x, y, &z); cout << x " + " << y << " = " << z; return (0);} void soma(int a, int b, int *c) { *c = a + b; } xyz VI) antes do final da execução da função main caixa do programa principal pilha de memória VI 235

45 Funções + 1 Exemplo //Exemplo: passagem de parâmetros por endereco ou referencia #include using namespace std; void somar (int*, int*); // protótipo da função somar() int main(){ int valor1=10, valor2=40; cout << "valor1 (antes): " << valor1; //10 somar(&valor1, &valor2); // chama a função somar() cout << "\nvalor1 (depois): " << valor1; //90 getchar (); getchar(); return 0; } void somar (int *v1, int *v2) // definição da função somar() { int total = *v1 + *v2; cout << "\nAdicao: " << total; //50 *v1=90; }

46 Funções – Parâmetros Resumo da características da Funções: nPortanto, Retorna um único valor nNa 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) nPara utilizar a função no programa principal basta colocar seu nome (identificador) e os parâmetros reais.

47 Funções – Parâmetros Vetores como Parâmetros nas Funções: nOs 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. n 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).

48 Funções – Parâmetros Vetores como Parâmetros nas Funções: nA 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 //Exemplo: passagem de parâmetros por endereco #include using namespace std; float media(int lista[], int tamanho); int main() { int const n = 5; int nota[n] = {10, 5, 8, 6, 6}; cout << "Media das notas = " << media(nota, n); getchar(); return (0); } float media(int lista[], int tamanho) { int i, smNotas = 0; for (i=0; i

50 Funções Funções Recursivas: nFunção recursiva é aquela que chama a si mesma. nSe 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 Funções Recursivas: nUm 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; } Função recursão (auto-delegação)

52 Funções Funções Recursivas - Exemplo: nEx. função para calcular o fatorial de número: n! = n * (n-1)! nFunção fatorial recursiva: se n = 0, o n! = 1; se n > 0, o n! = n * (n - 1)!;

53 #include using namespace std; int fat(int n); int main() { cout << "Fatorial de 2 = " << fat(2); return (0); } int fat(int n) { if (n == 0) return(1); else return(n * fat(n - 1)); } I) antes da chamada da função fat caixa do programa principal pilha de memória I

54 #include using namespace std; int fat(int n); int main() { cout << "Fatorial de 2 = " << fat(2); return (0); } int fat(int n) { if (n == 0) return(1); else return(n * fat(n - 1)); } II) após a chamada de fat(2) II caixa do programa principal pilha de memória fatn caixa da função fat(2) 2 * fat(1) 2

55 #include using namespace std; int fat(int n); int main() { cout << "Fatorial de 2 = " << fat(2); return (0); } int fat(int n) { if (n == 0) return(1); else return(n * fat(n - 1)); } III) fat(2) chama fat(1) III caixa do programa principal pilha de memória fatn caixa da função fat(2) 2 n 1 caixa da função fat(1) 2 * fat(1) fat 1 * fat(0)

56 #include using namespace std; int fat(int n); int main() { cout << "Fatorial de 2 = " << fat(2); return (0); } int fat(int n) { if (n == 0) return(1); else return(n * fat(n - 1)); } IV) fat(1) chama fat(0) IV caixa do programa principal pilha de memória caixa da função fat(2) caixa da função fat(1) n 10 caixa da função fat(0) fatn 2 n 12 * fat(1) fat 1 * fat(0) fat

57 #include using namespace std; int fat(int n); int main() { cout << "Fatorial de 2 = " << fat(2); return (0); } int fat(int n) { if (n == 0) return(1); else return(n * fat(n - 1)); } V) fat(0) é 1- ocorre o retorno na ordem inversa V caixa do programa principal pilha de memória caixa da função fat(2) 1 * fat(0) caixa da função fat(1) caixa da função fat(0) 2 * fat(1) fatn 2 n 1 n

58 #include using namespace std; int fat(int n); int main() { cout << "Fatorial de 2 = " << fat(2); return (0); } int fat(int n) { if (n == 0) return(1); else return(n * fat(n - 1)); } VI) antes do final da execução da função main caixa do programa principal pilha de memória VI 2

59 Funções Vantagem do uso de Funções: nNa Subdivisão de programas complexos: Cada parte menor tem um código mais simples; Facilita o entendimento (partes independentes); nEstruturação de programas; Detecção de erros e documentação de sistemas; nModularização de sistemas Desenvolvimento por equipes de programadores; Manutenção de software; Reutilização de trechos de código (bibliotecas, funções);

60 Referências nLopes, A. & Garcia, G. – Introdução a Programação. nSchildt – C Completo e Total.

61 Obrigado

62 E Agora??? Exercícios!!!

63 Exercícios Propostos 1.Desenvolver uma função MAIOR para determinar o maior elemento de um vetor de números inteiros. 2.Utilizar esta função para determinar o maior elemento de uma matriz de números inteiros de dimensão M x N.

64 FIM

65 //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; } 1.Desenvolver uma função MAIOR para determinar o maior elemento de um vetor de números inteiros.

66 #include using namespace std; #define TAM 50 //uma diretiva de compilacao para criar uma constante //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; cout << "FORNECA O VALOR DE Linhas: "; cin >> M; cout << "\nFORNECA O VALOR DE Colunas: "; cin >> N; 2.Utilizar esta função para determinar o maior elemento de uma matriz de números inteiros de dimensão M x N.

67 //carrega a matriz for (I=0; I < M; I++) { cout << "\n"; for (J=0; J < N; J++) { cout << "Elemento S[" << I << "][" << J << "]: "; cin >> S[I][J]; } } //imprime a matriz cout << "\n\nMatriz informada:\n"; for(I=0; I < M; I++){ cout << "\n\n"; for(J=0; J < N; J++) cout << "\t" << 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); getchar(); getchar(); return 0; }

68 Funções – Exercícios em Sala Funções e Vetores: nEscrever uma função para verificar se dois vetores de N números inteiros são iguais. nUtilizar esta função em um programa para verificar se duas matriz (M x M) lidas possuem a mesma diagonal principal. int COMPARA (int X[], int Y[], int T)

69 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.

70 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.

71 módulo chamador: cout << "Indice Massa Corporea = " << IMC(80, 1.77)); módulo chamado: int IMC(int pc, float alt) { return(pc / (alt * alt)); } 1.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)

72 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) cout << n << eh um nro par.; else cout << n << eh um nro ímpar.;

73 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.

74 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).

75 void soma(int a, int b, int *c) { *c = a + b; } int soma(int a, int b) { return(a + b); } Em Síntese: Módulo Chamador. variáveis locais do módulo chamador. argumentos ou paramêtros efetivos ou reais 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. cout << "5 + 3 = " << soma(5, 3); passagem de parâmetros tipo valor ou constante int result; soma(5, 3, &result); cout << "5 + 3 = " << result; passagem de parâmetro tipo variável ou referência Módulo Chamado. variáveis locais do módulo chamado. parâmetros formais


Carregar ppt "Algoritmos Escher. Agenda SubProgramas; Conceitos; Exercícios."

Apresentações semelhantes


Anúncios Google