1 Aula 06 – Funções Prof. Filipe Mutz Colocar mais exemplos de funções simples no começo.

Apresentação em tema: "1 Aula 06 – Funções Prof. Filipe Mutz Colocar mais exemplos de funções simples no começo."— Transcrição da apresentação:

1 1 Aula 06 – Funções Prof. Filipe Mutz Colocar mais exemplos de funções simples no começo

2 2 Introdução Funções são conjuntos de instruções que realizam uma tarefa específica. São usadas para expandir a linguagem e prover novas funcionalidades para os desenvolvedores. Nós já trabalhamos com diversas funções que o C disponibiliza em suas bibliotecas (e existem centenas de bibliotecas) stdio.h math.h Etc.

3 3 #include int main (void) { float a, b, c; float delta, x1, x2; printf("Digite os coeficientes: "); scanf("%f %f %f", &a, &b, &c); delta = pow(b, 2) - 4 * a * c; x1 = (-b + sqrt(delta)) / (2 * a); x2 = (-b - sqrt(delta)) / (2 * a); printf("Raizes: %f %f\n", x1, x2); return 0; } Funções possuem: Parâmetros (ou Argumentos): o que ela precisa para cumprir sua tarefa Resultados (ou Retornos): Qual é o resultado da tarefa. O que ela produz. Quando o conjunto de parâmetros ou de resultados é vazio, o chamamos de void. pow: recebe dois números (parâmetros) e produz outro número, o primeiro elevado ao segundo. sqrt: recebe um número (parâmetro) e produz como resultado a raíz do número. Cada vez que usamos uma função, estamos fazendo uma chamada da função. O resultado de uma função depende dos parâmetros usados. [veja as chamadas da sqrt]

4 4 #include float calcula_delta (float a, float b, float c) { float d = pow(b, 2) – 4 * a * c; return d; } int main (void) { float a, b, c; float delta; printf("Digite os coeficientes: "); scanf("%f %f %f", &a, &b, &c); delta = calcula_delta(a, b, c); printf(“Delta: %f\n", delta); return 0; } NomeDaFuncao ( ) { } Sintaxe de Definição de Funções

5 5 #include float calcula_delta (float a, float b, float c) { float d = pow(b, 2) – 4 * a * c; return d; } int main (void) { float a, b, c; float delta; printf("Digite os coeficientes: "); scanf("%f %f %f", &a, &b, &c); delta = calcula_delta(a, b, c); printf(“Delta: %f\n", delta); return 0; } NomeDaFuncao ( ) { } Sintaxe de Definição de Funções Os nomes das funções devem seguir as mesmas regras dos nomes das variáveis: Podem usar letras minúsculas e maiúsculas, algarismos, e underlines, mas não podem começar com algarismos. A instrução return é usada para retornar um determinado valor. O valor retornado deve ser do tipo especificado na função. A função termina automaticamente quando chegar na instrução return.

6 6 #include void mostra_texto(void) { printf(“Ola, sou uma funcao\n”); return; } int main (void) { mostra_texto(); return 0; } Se uma função não precisa de parâmetros dizemos que ela recebe void. Entenda isso como se o conjunto de parâmetros fosse vazio. Da mesma forma, se a função não produz nenhum resultado, dizemos que ela retorna void. A instrução return não é obrigatória em funções que retornam void, mas ela pode ser usada e, nesse caso, nenhum valor deve ser usado.

7 7 #include void mostra_raizes(float delta, float a, float b, float c) { float x1, x2; if (delta < 0) { printf(“Não existem raizes\n”); return; } x1 = (-b - sqrt(delta)) / (2 * a); x2 = (-b + sqrt(delta)) / (2 * a); printf(“raizes: %f %f\n”, x1, x2); } (...) Lembre-se: sempre que a instrução return for alcançada, a função termina imediatamente! (...) int main (void) { float a, b, c; float delta; printf("Digite os coeficientes: "); scanf("%f %f %f", &a, &b, &c); delta = pow(b, 2) – 4 * a * c; mostra_raizes (delta, a, b, c); return 0; }

8 8 #include void mostra_raizes(float delta, float a, float b, float c) { float x1, x2; if (delta < 0) { printf(“Não existem raizes\n”); } else { x1 = (-b - sqrt(delta)) / (2 * a); x2 = (-b + sqrt(delta)) / (2 * a); printf(“raizes: %f %f\n”, x1, x2); } (...) int main (void) { float a, b, c; float delta; printf("Digite os coeficientes: "); scanf("%f %f %f", &a, &b, &c); delta = pow(b, 2) – 4 * a * c; mostra_raizes (); return 0; } Outra forma de implementar a função sem usar o return.

9 9 Atenção! As funções devem ser declaradas, antes de serem usadas!

10 10 Atenção! As funções devem ser declaradas, antes de serem usadas! OK!

11 11 Atenção! As funções devem ser declaradas, antes de serem usadas! Forma Alternativa Declaração (protótitpo) Definição ou Implementação

12 12 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include void incremento (float x) { x++; } int main (void) { float x = 2; incremento(x); return 0; } ContextoNomeValor Estas variáveis são diferentes e estão em lugares diferentes da memória.

13 13 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include void incremento (float x) { x++; } int main (void) { float x = 2; incremento(x); return 0; } ContextoNomeValor

14 14 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include void incremento (float x) { x++; } int main (void) { float x = 2; incremento(x); return 0; } ContextoNomeValor mainx2

15 15 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include void incremento (float x) { x++; } int main (void) { float x = 2; incremento(x); return 0; } ContextoNomeValor mainx2 incrementox 1º É criada uma variável para armazenar o argumetno.

16 16 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include void incremento (float x) { x++; } int main (void) { float x = 2; incremento(x); return 0; } ContextoNomeValor mainx2 incrementox2 2º O valor do argumento é copiado.

17 17 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include void incremento (float x) { x++; } int main (void) { float x = 2; incremento(x); return 0; } ContextoNomeValor mainx2 incrementox2

18 18 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include void incremento (float x) { x++; } int main (void) { float x = 2; incremento(x); return 0; } ContextoNomeValor mainx2 incrementox2

19 19 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include void incremento (float x) { x++; } int main (void) { float x = 2; incremento(x); return 0; } ContextoNomeValor mainx2 incrementox3

20 20 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include void incremento (float x) { x++; } int main (void) { float x = 2; incremento(x); return 0; } ContextoNomeValor mainx2

21 21 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include void incremento (float x) { x++; } int main (void) { float x = 2; incremento(x); return 0; } ContextoNomeValor mainx2

22 22 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor

23 23 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor mainx987213971 mainy12376123

24 24 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor mainx2 y12376123

25 25 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor mainx2 y12376123 x: 2

26 26 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor mainx2 y12376123 x: 2

27 27 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor mainx2 y12376123 quadradox2 x: 2

28 28 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor mainx2 y12376123 quadradox4 x: 2

29 29 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor mainx2 y4 quadradox4 x: 2

30 30 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor mainx2 y4 x: 2

31 31 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor mainx2 y4 x: 2 ???????????????

32 32 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor mainx2 y4 x: 2 x: 2 y: 4

33 33 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor mainx2 y4 x: 2 x: 2 y: 4

34 34 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor mainx2 y4 quadradox4 x: 2 x: 2 y: 4

35 35 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor mainx2 y4 quadradox16 x: 2 x: 2 y: 4

36 36 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor mainx16 mainy4 quadradox16 x: 2 x: 2 y: 4

37 37 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor mainx16 mainy4 x: 2 x: 2 y: 4

38 38 Parâmetros Neste curso, vamos trabalhar com passagem de parâmetro por cópia. Significa que as variáveis que mandamos não se alteram, são cópias! #include float quadrado (float x) { x = pow(x, 2); return x; } int main (void) { float x, y; x = 2; printf("x: %f\n", x); y = quadrado(x); printf("x: %f y: %f\n", x, y); x = quadrado(y); printf("x: %f y: %f\n", x, y); return 0; } ContextoNomeValor mainx16 mainy4 x: 2 x: 2 y: 4 x: 16 y: 4

39 39 Exercícios 1.Crie uma função que some o quadrado de dois números. 2.Crie uma função que calcula a distância euclidiana entre dois pontos dados. 3.Que tal implementar a função pow para inteiros?

40 40 Escopo de variáveis em funções Escopo: a grosso modo, significa: “onde uma variável é válida” Escopo Local: Variáveis declaradas em uma funções só existirão dentro desta função. Se uma variável com o mesmo nome for criada em outra função, elas são variáveis diferentes. Escopo Global: São variáveis declaradas fora de qualquer função. ATENÇÃO: todas as funções podem ler e escrever em variáveis globais!

41 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor

42 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx

43 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx

44 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx2

45 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx2

46 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx2

47 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx4

48 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx4

49 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx4

50 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx4

51 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx16

52 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx16

53 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx16

54 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx16

55 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx256

56 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx256

57 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx256

58 #include float x; void quadrado_x (void) { x = pow(x, 2); } int main (void) { x = 2; quadrado_x(); return 0; } ContextoNomeValor GLOBALx256 Variáveis globais tornam o código difícil de ser lido! Só use quando for realmente necessário!!!!

59 59 Por que usar funções? Agilizar o desenvolvimento pela capacidade de reuso Simplificar a manutenção dos códigos Correção de problemas centralizada Tornar códigos mais legíveis

60 60 Como usar funções na prática? Enquanto estiver escrevendo seu código, reflita e identifique funcionalidades que podem ser úteis a outras pessoas, ou em outros trechos do programa. Se uma função começar a crescer demais, quebre-a em funções menores. Idealmente, todas as funções devem caber em uma tela.

61 61 Exercícios [Obrigatório uso de funções] 1.Faça uma função que receba uma variável e retorne o seu módulo. 2.Faça um função que calcule a raiz enésima de um número.