Carregar apresentação
A apresentação está carregando. Por favor, espere
PublicouThais Santana Carlos Alterado mais de 7 anos atrás
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.
Apresentações semelhantes
© 2024 SlidePlayer.com.br Inc.
All rights reserved.