Objectivos. Iniciar a programação de funções. Estudar a chamada de funções. Estudar a forma como são executadas as funções

Transcrição

1 Funções

2 Objectivos Iniciar a programação de funções Estudar a chamada de funções Estudar a forma como são executadas as funções Passagem por valor e referência Como conceber funções 2

3 Programação modular Programação modular: divir um programa em módulos mais pequenos Função: um conjunto de instruções que desempenham uma tarefa Motivação da programação modular: Simplificar a manutenção dos programas Simplicar o processo de desenvolvimento de uma aplicação 3

4 Funções Os programas em C++ possuem geralmente o seguinte formato: as directivas de include os protótipos das funções a definição da função main() as definições das restantes funções 4

5 Definição e chamada de funções Definição da função: conjunto de instruções que implementa a função Chamada da função: instrução que conduz à execução de uma função 5

6 Definições de funções Definição de funções Contém instruções que definem o comportamento quando uma função é chamada. Função deve ser definida para ser chamada Senão um erro de ligação ocorre. Padrão: TipoRetornado Nome (DeclaracoesParametros) { Lista_de_Instrucoes } 6

7 Definição de uma função A definição inclui: O tipo retornado: tipo de dados do valor que a função retorna para o parte do programa que fez a sua chamada O nome: nome da função. O nome da função segue as mesmas regras que as outras variáveis A Lista de parâmetros: tipos e nome das variáveis contendo os valores passados para a função O corpodafunção: instruções que realizam a a operação pretendida. Sempre englobado por {} 7

8 Tipo retornado Se uma função retorna um valor, o tipo de dados do valor tem que ser indicado: int main() Se a função não retorna um valor, o seu tipo é void: void saudacao() { cout << "\tbom dia!\n"; } 8

9 Chamada a uma função Na chamada à função que retorna void, utiliza-se o nome da função seguido de () e ; saudacao(); Quando a função é chamada, o programa executa o corpo da função Após o fim da execução da função, a execução segue no ponto da sua chamada 9

10 Chamada a uma função O fluxo de execução na chamada a uma função: 10

11 Chamada a uma função A função main() pode chamar qualquer número de funções As funções podem chamar outras funções O compilador tem que saber o seguinte sobre uma função antes da sua chamada: Nome Tipo retornado Número de parâmetros Tipo de dados de cada parâmetro 11

12 Documentação de uma função A definição de uma função deve ser precedida por comentários que indicam: O propósito da função O que faz e como o faz Valores de entrada esperados, se existirem Valores que retorna, se existirem Saída que realiza, se alguma 12

13 Protótipo de funções Funciona como a declaração da função Padrão: TipoRetornado Nome (DeclaracoesParametros); 13

14 Funções que não retornam nada É comum haver funções que têm tarefas repetidas, tais como: Mostrar no écran valores Isto pode ser feito com funções void : Exemplo void mostravaloresmonetarios(double euros) 14

15 Protótipo ou declaração de funções Modos de notificar o compilador sobre uma função antes de fazer a sua chamada: Colocar a definição da função antes da sua chamada Colocar o protótipo da função (declaração da função) antes da sua chamada: void exemplo(int val1, double val2); 15

16 Protótipos Colocar os protótipos no cabeçalho do programa Quando se utilizam protótipos, as definições das funções podem aparecer por qualquer ordem no programa fonte 16

17 Enviar dados para uma função Pode-se passar valores para uma função na chamada à função: c = sqrt(a*a + b*b); Valores passados para uma função são argumentos da função Variáveis da função que guardam os valores passados como argumentos são parâmetros 17

18 Enviar dados para uma função Um parâmetro também pode ser denominado por parametro formal ou argumento formal Um argumento também pode ser denominado por parâmetro real (actual parameter) ou argumento real (actual argument) 18

19 Parâmetros, protótipos e definição de funções Para cada argumento da função, O protótipo tem que incluir o tipo de cada parâmetro nos() A definição da função tem que incluir a definição de cada parâmetro nos () bool parouimpar(int); //protótipo bool parouimpar (int num) //definição parouimpar(val); //chamada 19

20 Chamada de uma função: como funciona Os argumentos são avaliados O valor dos argumentos são copiados para os respectivos parâmetros O âmbito (scope) é a função que o utiliza Uma função pode ter mais do que um parâmetro Tem que existir uma lista dos tipos de dados no protótipo nos() e uma definição dos parâmetros, nos(), na definição da função Os argumentos serão promovidos/despromovidos de modo a coincidir com o tipos dos parâmetros 20

21 Passagem de dados por valor Passagem por valor: quando um argumento é passado para uma função, o seu valor é copiado para o parâmetro respectivo Alterações no parâmetro não afectam o valor do argumento 21

22 Passagem de dados por valor para parâmetros Exemplo: int val=5; duplica(val); val 5 argumento num 5 parâmetro duplica pode alterar a variável num, mas não irá afectar a variável val 22

23 A instrução return Utilizada para finalizar a execução de uma função Pode ser colocada em qualquer local da função Instruções que se sigam ao return não serão executadas Sem um return, a função termina a sua execução na última } 23

24 Retornar um valor de uma função A instrução return pode ser utilizada para retornar um valor (um objecto!) O protótipo e a definição devem indicar o tipo de dados retornado O valor retornado por uma função pode ser: Atribuído a uma variável Enviado para cout Utilizado numa expressão 24

25 A instrução return:exemplo bool validanota(int nota); // protótipo bool validanota(int nota) // definição { int liminf = 0, limsup = 100; if (nota >= liminf && nota <= limsup) return true; else return false; } if (validanota(exame)) {...} // chamada 25

26 Passagem por valor Passagem por valor Gera uma variável diferente, contendo uma cópia do seu argumento No exemplo em seguida, op1 e op2 são parâmetros passados por valor. 26

27 Passagem por referência Mecanismo que permite a uma função trabalhar com o argumento original da chamada à função, e não com uma cópia do argumento Permite que uma função modifique valores armazenados no âmbito da chamada à função Permite que a função retorne (devolva) mais do que valor 27

28 Passagem por referência Passagem por referência Um nome alternativo (alias) do argumento correspondente da chamada Modificar o valor do parâmetro passado por referência, implica uma modificação no argumento correspondente de chamada 28

29 Passagem por referência A um parâmetro de referência está associado o endereço de outra variável: o argumento correspondente na chamada à função. Parâmetro de referência é definido com um & void dimensoes(int&, int&); Alterações num parâmetro de referência são também efectuadas no argumento correspondente na chamada à função. 29

30 Passagem por referência: exemplo void quadrado(int &); //protótipo void quadrado(int &num) // definição { num *= num; } int valor = 5; quadrado(valor); // chamada // valor = 25 30

31 Exemplo: divisão inteira Considere a tarefa de dividir dois inteiros Podemos obter o quociente e o resto Queremos uma função que retorne os dois valores Objectos Descrição Objectos Tipo Espécie Movimento Nome primeiro operando integer variável recebida operando1 segundo operando integer variável recebida operando2 quociente da divisão integer variável resto da divisão integer variável recebida e devolvida recebida e devolvida quociente resto 31

32 Problema De acordo com a tabela anterior, a função tem de retornar dois objectos As funções só podem retornar um objecto Os parâmetros que vimos até ao momento, foram passados por valor. São criadas cópias dos seus argumentos. A mudança do valor de um parâmetro, muda apenas a cópia, não alterando o valor do argumento. 32

33 Solução: passagem por referência Passagem de parâmetros por referência Os parâmetros são declarados com um & após o tipo do parâmetro e antes do respectivo nome. Um parâmetro por referência é um nome alternativo (alias) para o argumento correspondente. Mudar o valor do parâmetro por referência muda o valor do seu argumento correspondente. 33

34 Passagem por referência Cabeçalho da função com passagem de parâmetros por referência: void divideinteiros (int operando1, int operando2, int& quociente, int& resto) quociente e resto recebem os valores apropriados nas expressões de atribuição Os parâmetros de chamada recebem esses valores 34

35 Programa testadivisaoint.cpp #include <iostream> #include <cassert> using namespace std; // <<, cout, endl // assert() void divideinteiros(int operando1, int operando2, int& quociente, int& resto); int main() { cout << " Tabela de divisao\n\n"; int quociente, // variaveis para guardar os valores resto; // devolvidos por divideinteiros() for (int j = 1; j <= 4; j++) { for (int i = 1; i <= 4; i++) { divideinteiros (i, j, quociente, resto); cout << i << " divido por " << j << " da' o quociente de " << quociente << " e o resto de " << resto << endl; } cout << endl; } } 35

36 Programa testadivisaoint.cpp void divideinteiros(int operando1, int operando2, int& quociente, int& resto) { assert (operando2!= 0); quociente = operando1 / operando2; resto = operando1 % operando2; } Note-se quociente e resto na chamada da funcão for (int j = 1; j <= 4; j++) { for (int i = 1; i <= 4; i++) { divideinteiros (i, j, quociente, resto);... Estas variáveis contêm os valores das variáveis quando a função acaba a sua execução. 36

37 Teste de execução Tabela de divisao 1 divido por 1 da' o quociente de 1 e o resto de 0 2 divido por 1 da' o quociente de 2 e o resto de 0 3 divido por 1 da' o quociente de 3 e o resto de 0 4 divido por 1 da' o quociente de 4 e o resto de 0 1 divido por 2 da' o quociente de 0 e o resto de 1 2 divido por 2 da' o quociente de 1 e o resto de 0 3 divido por 2 da' o quociente de 1 e o resto de 1 4 divido por 2 da' o quociente de 2 e o resto de 0 1 divido por 3 da' o quociente de 0 e o resto de 1 2 divido por 3 da' o quociente de 0 e o resto de 2 3 divido por 3 da' o quociente de 1 e o resto de 0 4 divido por 3 da' o quociente de 1 e o resto de 1 1 divido por 4 da' o quociente de 0 e o resto de 1 2 divido por 4 da' o quociente de 0 e o resto de 2 3 divido por 4 da' o quociente de 1 e o resto de 3 4 divido por 4 da' o quociente de 1 e o resto de 0 37

38 Passagem por referência Cada parâmetro passado por referência deve conter & O espaço entre o tipo e o & não é obrigatório Tem que ser utilizado o & no protótipo e na definição Argumentos passados por referência têm que ser variáveis não podem ser uma expressão ou um literal 38

39 Passagem por valor Os parâmetros na chamada devem ser variáveis ou literais ou expressões do mesmo tipo do da declaração. Objectos de grande dimensão passados por valor podem ocupar espaço ou tempo excessivo string mascote (string universidade) { if (universidade == "Illinois") return "Fighting Illini";... } ---- cout << mascote(escola) << endl; 39

40 Passagem de argumentos A cópia do argumento escola consome tempo. Especialmente se o argumento for uma estrutura grande A criação de um alias para um argumento é quase imediata. Poder-se-á aumentar a velocidade passando o parâmetro universidade por referência. No entanto, isto é arriscado: Podemos mudar o valor de escola se por engano mudarmos o valor de universidade. 40

41 Solução Parâmetros por referência constantes Parâmetros por referência cuja declaração é precedida pela palavra-chave const. string mascote (const string& universidade) { if (universidade == "Illinois") return "Fighting Illini";... } Parâmetros por referência constantes são parâmetros só de leitura dos seus argumentos Assim, não podem ser alterados 41

42 Concepção de funções Especificação da função Determina a forma do cabeçalho da função Valor a retornar Nome Parâmetros Algoritmo da função Determina o conteúdo do corpo da função Input, Output Ramificações, ciclos Testes, execução e debugging Programa driver 42

43 Funções são subprogramas Os passos de concepção de um programa podem ser utilizados para as funções 1. Comportamento 2. Objectos 3. Operações 4. Algoritmo 5. Codificação 6. Testes, execução, debugging 7. Manutenção Comportamento das dasfunções inclui: Recebe valores quado é chamada Retorna valores no no final final da daexecução 43

44 Problema As duas escalas mais utilizadas para medir temperaturas são as Fahrenheit e Celsius. É necessário um programa para converter temperaturas de graus Fahrenheit em graus Celsius, utilizando uma função de conversão. Comportamento Insira a temperatura em Fahrenheit a converter para graus Celsius: 99 Temperatura em Celsius:

45 Comportamento e objectos da função fahremcelsius() Recebe valor temperatura Fahrenheit quando chamada Faz a conversão com a respectiva equação Retorna o valor da temperatura equivalente em Celsius Descrição Objectos Tipo Espécie Movimento Nome Temperatura Fahrenheit double variável recebida (in) temperaturafahr Temperatura Celsius double variável devolvida (out) 45

46 Parâmetros As variáveis das funções para as quais os valores podem ser especificados. São definidas entere parêntesis na definição da funcão. double fahremcelsius(double temperaturafahr) { return (temperaturafahr ) / 1.8; } 46

47 Argumentos Quando uma função é chamada A chamada passa os seus valores como argumentos Estes são gravados nos parâmetros da função. double novatemperatura = fahremcelsius(212) 212 double fahremcelsius(double temperaturafahr) { return (temperaturafahr ) / 1.8; } A função corre assim usando os seus parâmetros. 47

48 Programa converte_temp.cpp /* converte_temp.cpp converte uma temperatura de graus Fahrenheit * Para graus Celsius, utilizando respectiva a formula de conversão. * * Input: tempfahrenheit * Output: tempcelsius *******************************************************************/ #include <iostream> using namespace std; double fahremcelsius(double temperaturafahr); // protótipo da funcao int main() { cout << "Este programa converte uma temperatura\n" << "de graus Fahrenheit para graus Celsius.\n"; cout <<"\ninsira a temperatura em graus Fahrenheit: "; double tempfahrenheit; cin >> tempfahrenheit; 48

49 converte_temp.cpp double tempcelsius = fahremcelsius(tempfahrenheit); } cout << tempfahrenheit << " graus Fahrenheit e equivalente a " << tempcelsius << " graus Celsius\n"; /* fahremcelsius converte uma temperatura de graus Fahrenheit * em graus Celsius. * * Recebe: temperaturafahr, um real com a temperatura em Fahrenheit * Retorna: a temperatura em graus Celsius equivalente ******************************************************************/ double fahremcelsius(double temperaturafahr) // definicao da funcao { return (temperaturafahr ) / 1.8; } 49

50 Fluxo de execução 50

51 Drivers e Stubs Driver: função que testa outra função fazendo a sua chamada Útil para testes e debug de funções Stub: função simplificada em substituição da verdadeira função Usualmente apresenta uma mensagem indicando que a função foi chamada. Útil para o teste de programas, de modo a verificar o seu funcionamento lógico 51

52 Stub: exemplo int main( ) { for (int contador = 1; contador <= 2; contador++) { cout << Chamada a aminhafuncao com contador = " << contador << endl; aminhafuncao(contador); } } void aminhafuncao(int valor) { cout << A aminhafuncao devolveu: " << valor <<endl; } 52

53 Mais exemplos de funções double AreaElipse(double comprimento, double largura); { const double PI = ; double metadecomprimento = comprimento /2.0, metadelargura = largura/2.0; return PI * metadecomprimento * metadelargura; } double PerimetroElipse(double comprimento, double largura); { const double PI = ; double metadecomprimento = comprimento /2.0, metadelargura = largura/2.0; return 2.0 * PI * sqrt((pow(metadecomprimento,2) + pow(metadelargura,2))/2.0); } 53

54 Exemplo de protótipos #include <iostream> // cin, cout, <<, >>,... #include <cmath> // sqrt(), pow(),... using namespace std; double AreaElipse(double comprimento, double largura); double PerimetroElipse(double comprimento, double largura); int main() { cout << \npara calcular a area e o perimetro de uma << \n elipse, insira o seu comprimento e largura: ; double comprimento, largura; cin >> comprimento >> largura; double area = AreaElipse(comprimento, largura); double perimetro = PerimetroElipse(comprimento, largura); } cout << \no valor da area e << area << \n e o do perimtro e << perimetro << endl; Para Para chamar uma umafunção, utiliza-se o seu seu nome nomecomo comose se fosse fosse uma umaexpressão 54

55 Exemplo: função que calcula o mínimo Problema: Escrever uma função que, dados dois números reais, retorne o mínimo dos dois valores. Comportamento: Recebe dois valores reais como parâmetros Se o primeiro é menor do que o segundo, retorna o primeiro valor Caso contrário retorna o segundo valor 55

56 Exemplo: função que calcula o mínimo (cont.) Objectos: Descrição Objectos (entidades) Tipo Espécie Movimento Nome primeiro valor double variável recebida primeiro segundo valor double variável recebida segundo valor mínimo double variável devolvida 56

57 Exemplo: função que calcula o mínimo (cont.) Operações i. Receber dois valores reais ii. Comparar os dois valores para ver qual deles é o menor iii. Retornar o primeiro valor iv. Retornar o segundo valor v. Seleccionar iii. ou iv. (não ambos!), baseado no resultado de ii. Algoritmo Se primeiro < segundo devolve primeiro; caso contrário devolve segundo. 57

58 Programa TestaMinimo.cpp /* TestaMinimo.cpp testa a funcao minimo. ****************************************************************/ #include <iostream> // cin, cout, <<, >> using namespace std; double minimo(double primeiro, double segundo); int main() { double numero1, numero2; cout << Insira dois numeros: "; cin >> numero1 >> numero2; cout << "Minimo e " << minimo(numero1, numero2) << endl; } /* minimo encontra o minimo de dois reais (dupla precisao). * * Recebe: primeiro e segundo * Devolve: o menor valor de primeiro e segundo ************************************************/ double minimo(double primeiro, double segundo) { if (primeiro < segundo) return primeiro; else return segundo; } 58

59 Testes da função Insira dois numeros: -2-6 Minimo e -6 Insira dois numeros: 3 6 Minimo e 3 Insira dois numeros: Minimo e