Programação Estruturada Prof. Rodrigo Hausen Ponteiros e Passagem de Parâmetros
|
|
|
- Nathan Carlos
- 5 Há anos
- Visualizações:
Transcrição
1 Programação Estruturada Prof. Rodrigo Hausen Ponteiros e Passagem de Parâmetros 1
2 AULA PASSADA - ponteiros Uma declaração tal como: tipo *nome; Declara um ponteiro: referência a uma posição de memória onde se encontra uma variável daquele tipo. Exemplos: int *numeros; double *notas; char *nomedomes; Obs.: se apenas declararmos o ponteiro, ele indicará uma região indeterminada. 2
3 AULA PASSADA - ponteiros Podemos declarar um ponteiro, alocar uma região de memória no heap e fazer a referência apontar para essa região alocada: tipo *ptr = (tipo *)malloc(n*sizeof(tipo)); O que isto faz: 1) declara ponteiro ptr para tipo 2) aloca espaço para n elementos, cada um com tamanho sizeof(tipo) 3) (tipo *) converte o ponteiro sem tipo retornado por malloc p/ tipo correto 4) faz ptr apontar para o primeiro elemento da região 3
4 PONTEIROS exemplo exptr.c #include <stdlib.h> // para usar malloc #include <stdio.h> // para usar puts int main(void) { char *p = (char*)malloc(3*sizeof(char)); if (p == NULL) return 1; p[0] = 'o'; p[1] = 'i'; p[2] = '\0'; puts(p); p[0] = 'h'; puts(p); free(p); 4
5 PONTEIROS exemplo exptr.c #include <stdlib.h> // para usar malloc #include <stdio.h> // para usar puts int main(void) { char *p = (char*)malloc(3*sizeof(char)); if (p == NULL) return 1; p[0] = 'o'; Sempre verifique se o p[1] = 'i'; ponteiro retornado por p[2] = '\0'; malloc é válido! puts(p); p[0] = 'h'; puts(p); free(p); 5
6 PONTEIROS exemplo exptr.c #include <stdlib.h> // para usar malloc #include <stdio.h> // para usar puts int main(void) { char *p = (char*)malloc(3*sizeof(char)); if (p == NULL) return 1; p[0] = 'o'; p[1] = 'i'; p[2] = '\0'; Após o último uso, puts(p); sempre libere a área p[0] = 'h'; alocada. puts(p); free(p); 6
7 PONTEIROS exemplo exptr.c #include <stdlib.h> // para usar malloc #include <stdio.h> // para usar puts int main(void) { char *p = (char*)malloc(3*sizeof(char)); if (p == NULL) return 1; p[0] = 'o'; p[1] = 'i'; p[2] = '\0'; Saída: puts(p); oi p[0] = 'h'; hi puts(p); free(p) 7
8 PONTEIROS exemplo exptr2.c Edite e compile o programa exptr2.c: #include <stdio.h> // para usar puts int main(void) { char str[] = "oi"; char *p = str; puts(str); puts(p); p[0] = 'h'; puts(str); puts(p); Explique o comportamento do programa. 8
9 PONTEIROS exemplo exptr2.c Edite e compile o programa exptr2.c: #include <stdio.h> // para usar puts int main(void) { char str[] = "oi"; char *p = str; puts(str); Saída: puts(p); oi p[0] = 'h'; oi puts(str); hi puts(p); hi Explique o comportamento do programa. 9
10 PONTEIROS exemplo exptr2.c Edite e compile o programa exptr2.c: #include <stdio.h> // para usar puts int main(void) { char str[] = "oi"; char *p = str; puts(str); Saída: puts(p); oi p[0] = 'h'; oi puts(str); hi puts(p); hi p e str apontam para a mesma região de mem. 10
11 PONTEIROS exemplo exptr3.c Edite e compile o programa exptr3.c: #include <stdio.h> // para usar puts int main(void) { char *str = "oi"; char *p = str; puts(str); puts(p); p[0] = 'h'; puts(str); puts(p); O que houve? 11
12 PONTEIROS - exemplo exptr3.c Edite e compile o programa exptr3.c: #include <stdio.h> // para usar puts int main(void) { char *str = "oi"; char *p = str; puts(str); puts(p); Saída: p[0] = 'h'; oi puts(str); oi puts(p); Falha de segmentação O que houve? 12
13 PONTEIROS - exemplo exptr3.c int main(void) { char *str = "oi"; char *p = str; puts(str); faz str apontar para a constante oi puts(p); p[0] = 'h'; puts(str); puts(p); 13
14 PONTEIROS - exemplo exptr3.c int main(void) { char *str = "oi"; char *p = str; puts(str); puts(p); p[0] = 'h'; puts(str); faz p apontar para a mesma região de memória que str (lembre: a região de memória é imutável pois guarda uma constante) puts(p); 14
15 PONTEIROS - exemplo exptr3.c int main(void) { char *str = "oi"; char *p = str; puts(str); puts(p); p[0] = 'h'; imprime a string apontada por str puts(str); puts(p); 15
16 PONTEIROS - exemplo exptr3.c int main(void) { char *str = "oi"; char *p = str; puts(str); puts(p); p[0] = 'h'; imprime a string apontada por p puts(str); puts(p); 16
![puts(p); p[0] = 'h'; puts(str); tenta alterar o primeiro](/docs-images/96/126965723/images/17-1.jpg "caractere da região apontada por p como a região apontada por p")
17 PONTEIROS - exemplo exptr3.c int main(void) { char *str = "oi"; char *p = str; puts(str); puts(p); p[0] = 'h'; puts(str); tenta alterar o primeiro caractere da região apontada por p como a região apontada por p faz parte de área de memória imutável... puts(p); 17
18 Moral dos exemplos exptr1.c a exptr3.c Um ponteiro pode indicar uma área de memória no heap, na pilha ou em outras regiões de memória (se houver), que podem ser imutáveis Declara ponteiro e aloca espaço no heap (deve ser desalocado c/ free): char *p = (char *)malloc(tamanho); Declara ponteiro e aloca espaço na pilha (desalocação automática): char p[] = "inicialização"; Declara ponteiro e aponta p/ uma constante (região imutável): char *p = "inicialização"; 18
19 PONTEIROS - exemplo exptr4.c #include <stdio.h> int main(void) { int i = 42; int *p = &i; printf("i é %d\n", i); p[0]++; printf("i é %d\n", i); 19
20 PONTEIROS - exemplo exptr4.c #include <stdio.h> int main(void) { int i = 42; int *p = &i; Operador & retorna referência (endereço) da posição de memória onde está armazenada a variável printf("i é %d\n", i); p[0]++; printf("i é %d\n", i); 20
21 PONTEIROS - exemplo exptr4.c #include <stdio.h> int main(void) { int i = 42; int *p = &i; printf("i é %d\n", i); p[0]++; printf("i é %d\n", i); Saída: i é 42 i é 43 Por que o valor de i mudou? Por que não fez cabum? 21
22 PONTEIROS - exemplo exptr5.c #include <stdio.h> int main(void) { int i[] = { 42, 99 ; int *p = i; printf("i[0] é %d\n", i[0]); p[0]++; printf("i[0] é %d\n", i[0]); Funciona? 22
23 PONTEIROS - exemplo exptr6.c #include <stdio.h> int main(void) { static const int i[] = { 42, 99 ; int *p = i; printf("i[0] é %d\n", i[0]); p[0]++; printf("i[0] é %d\n", i[0]); Funciona? 23
24 OPERAÇÕES com PONTEIROS Operador de referência & Colocado na frente de uma variável, nos dá o endereço onde esta variável está armazenada. int i = 42; int *p = &i; p[0]++; // incrementa o primeiro int // na região de memória apontada // por p 24
25 OPERAÇÕES com PONTEIROS Operador de referência & Colocado na frente de uma variável, nos dá o endereço onde esta variável está armazenada. Por que não se usa o operador & abaixo? int i[] = { 42, 99 ; int *p = i; p[0]++; 25
26 OPERAÇÕES com PONTEIROS Operador de dereferência * Colocado na frente de uma variável ou expressão, permite acessar o conteúdo da posição de memória apontada por essa variável ou expressão. int i = 42; int *p = &i; ++(*p); // equivale a ++p[0] Atenção! Neste exmplo, apenas este uso do caractere * indica o operador de dereferência! 26
27 OPERAÇÕES com PONTEIROS Operador de dereferência * Infelizmente, a notação é confusa. O caractere * indica dereferência se não vier imediatamente precedido por um tipo. int *p; // declara variável do tipo // ponteiro para int *p = 42; // coloca na posição de memória // apontada por p o número 42 27
28 Experimento no cling Inicie o cling (se já tiver iniciado, saia com.q e reinicie-o) #include <stdio.h> int a[] = { 18, 33, 99 ; int b[] = { 42, 21 ; 28
29 Experimento no cling Inicie o cling (se já tiver iniciado, saia com.q e reinicie-o) #include <stdio.h> int a[] = { 18, 33, 99 ; int b[] = { 42, 21 ; int *p = a; int *q = b; 29
30 Experimento no cling Inicie o cling (se já tiver iniciado, saia com.q e reinicie-o) #include <stdio.h> int a[] = { 18, 33, 99 ; int b[] = { 42, 21 ; int *p = a; int *q = b; printf("%d\n", p); 30
31 Experimento no cling Inicie o cling (se já tiver iniciado, saia com.q e reinicie-o) #include <stdio.h> int a[] = { 18, 33, 99 ; int b[] = { 42, 21 ; int *p = a; int *q = b; printf("%d\n", p); Warning: (tentando imprimir um ponteiro com %d ) 31
32 Experimento no cling Inicie o cling (se já tiver iniciado, saia com.q e reinicie-o) #include <stdio.h> int a[] = { 18, 33, 99 ; int b[] = { 42, 21 ; int *p = a; int *q = b; printf("%d\n", p); Warning: (tentando imprimir um ponteiro com %d ) printf("%d\n", *p); 32
33 Experimento no cling Inicie o cling (se já tiver iniciado, saia com.q e reinicie-o) #include <stdio.h> int a[] = { 18, 33, 99 ; int b[] = { 42, 21 ; int *p = a; int *q = b; printf("%d\n", p); Warning: (tentando imprimir um ponteiro com %d ) printf("%d\n", *p); 18 33
34 Experimento no cling Inicie o cling (se já tiver iniciado, saia com.q e reinicie-o) #include <stdio.h> int a[] = { 18, 33, 99 ; int b[] = { 42, 21 ; int *p = a; int *q = b; printf("%d\n", p); Warning: (tentando imprimir um ponteiro com %d ) printf("%d\n", *p); 18 printf("%d\n", *q); 34
35 Experimento no cling Inicie o cling (se já tiver iniciado, saia com.q e reinicie-o) #include <stdio.h> int a[] = { 18, 33, 99 ; int b[] = { 42, 21 ; int *p = a; int *q = b; printf("%d\n", p); Warning: (tentando imprimir um ponteiro com %d ) printf("%d\n", *p); 18 printf("%d\n", *q); 42 35
36 Experimento no cling Inicie o cling (se já tiver iniciado, saia com.q e reinicie-o) #include <stdio.h> int a[] = { 18, 33, 99 ; int b[] = { 42, 21 ; int *p = a; int *q = b; printf("%d\n", p);! g n i l Warning: (tentando imprimir um ponteiro com %d ) c o. n.. a e l ç e printf("%d\n", e*p); n a a s o m Per ltarem 18 o v á J printf("%d\n", *q); 42 36
37 ARITMÉTICA DE PONTEIROS Podemos fazer contas aritméticas e apontar para outras regiões de memória. 3 int a[]={ 18,33,99 ; int*p=a; int b[] = { 42, 21 ; int*q=b; q-p printf("end. de p: %p\n", p); printf("end. de q: %p\n", q); p q 37
38 ARITMÉTICA DE PONTEIROS Podemos fazer contas aritméticas e apontar para outras regiões de memória. 3 int a[]={ 18,33,99 ; int*p=a; int b[] = { 42, 21 ; int*q=b; q-p printf("end. de p: %p\n", p); printf("end. de q: %p\n", q); p p+1 p+2 p+3 == q q
39 ARITMÉTICA DE PONTEIROS (int) 18 (int) 42 (int) 99 (int) 42 *p *q *(p+2) *(p+3) p p+1 p+2 p+3 == q q
40 ARITMÉTICA DE PONTEIROS *(++p) Não pressione enter ainda! O que isto faz? Qual será o resultado? p p+1 p+2 p+3 == q q
41 ARITMÉTICA DE PONTEIROS *(++p) (int) p p+1 p+2 == q q
42 ARITMÉTICA DE PONTEIROS *(++p) (int) 33 *(p++) p p+1 p+2 == q q
43 ARITMÉTICA DE PONTEIROS *(++p) (int) 33 *(p++) (int) p p+1 == q q
44 ARITMÉTICA DE PONTEIROS *(++p) (int) 33 *(p++) (int) 33 *p p p+1 == q q
45 ARITMÉTICA DE PONTEIROS (int) 33 (int) 33 (int) 99 *(++p) *(p++) *p p p+1 == q q
46 ARITMÉTICA DE PONTEIROS (int) 33 (int) 33 (int) 99 *(++p) *(p++) *p *(--p) p p+1 == q q
47 ARITMÉTICA DE PONTEIROS (int) 33 (int) 33 (int) 99 (int) 33 *(++p) *(p++) *p *(--p) p p+1 p+2 == q q
48 ARITMÉTICA DE PONTEIROS palindromo.c int palindromo(const char *p) { 48
49 ARITMÉTICA DE PONTEIROS palindromo.c int palindromo(const char *p) { const char *q = p; 49
50 ARITMÉTICA DE PONTEIROS palindromo.c int palindromo(const char *p) { const char *q = p; // localiza final da string while (*q!= '\0') ++q; 50
51 ARITMÉTICA DE PONTEIROS palindromo.c int palindromo(const char *p) { const char *q = p; // localiza final da string while (*q!= '\0') ++q; --q; // q aponta para último char // diferente de '\0' 51
52 ARITMÉTICA DE PONTEIROS palindromo.c int palindromo(const char *p) { const char *q = p; // localiza final da string while (*q!= '\0') ++q; --q; // q aponta para último char // diferente de '\0' // compara while (p < q) { 52
53 ARITMÉTICA DE PONTEIROS palindromo.c int palindromo(const char *p) { const char *q = p; // localiza final da string while (*q!= '\0') ++q; --q; // q aponta para último char // diferente de '\0' // compara while (p < q) { if (*p!= *q) return 0; // falso 53
54 ARITMÉTICA DE PONTEIROS palindromo.c int palindromo(const char *p) { const char *q = p; // localiza final da string while (*q!= '\0') ++q; --q; // q aponta para último char // diferente de '\0' // compara while (p < q) { if (*p!= *q) return 0; // falso ++p; --q; 54
55 ARITMÉTICA DE PONTEIROS palindromo.c int palindromo(const char *p) { const char *q = p; // localiza final da string while (*q!= '\0') ++q; --q; // q aponta para último char // diferente de '\0' // compara while (p < q) { if (*p!= *q) return 0; // falso ++p; --q; return 1; // verdadeiro 55
56 ARITMÉTICA DE PONTEIROS palindromo.c Reinicie o cling e teste:.l palindromo.c palindromo("roma amor") 56
57 ARITMÉTICA DE PONTEIROS palindromo.c Reinicie o cling e teste:.l palindromo.c palindromo("roma amor") (int) 1 // verdadeiro 57
58 ARITMÉTICA DE PONTEIROS palindromo.c Reinicie o cling e teste:.l palindromo.c palindromo("roma amor") (int) 1 // verdadeiro palindromo("anemona") 58
59 ARITMÉTICA DE PONTEIROS palindromo.c Reinicie o cling e teste: (int) 1 (int) 0.L palindromo.c palindromo("roma amor") // verdadeiro palindromo("anemona") // falso 59
60 ARITMÉTICA DE PONTEIROS palindromo.c Reinicie o cling e teste: (int) 1 (int) 0.L palindromo.c palindromo("roma amor") // verdadeiro palindromo("anemona") // falso palindromo("") 60
61 ARITMÉTICA DE PONTEIROS palindromo.c Reinicie o cling e teste: (int) 1 (int) 0 (int) 1.L palindromo.c palindromo("roma amor") // verdadeiro palindromo("anemona") // falso palindromo("") // verdadeiro A string vazia é palíndroma, pois equivale a ela mesma lida de trás para frente. 61
62 'r''o''m''a'' ''a''m''o''r''\0' p int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 62
63 'r''o''m''a'' ''a''m''o''r''\0' pq int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 63
64 'r''o''m''a'' ''a''m''o''r''\0' pq int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 64
65 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 65
66 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 66
67 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 67
68 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 68
69 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 69
70 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 70
71 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 71
72 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 72
73 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 73
74 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 74
75 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 75
76 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 76
77 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 77
78 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 78
79 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 79
80 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 80
81 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 81
82 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 82
83 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 83
84 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 84
85 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 85
86 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 86
87 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 87
88 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 88
89 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 89
90 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 90
91 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 91
92 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 92
93 'r''o''m''a'' ''a''m''o''r''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 93
94 'a''n''e''m''o''n''a''\0' p int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 94
95 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 95
96 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 96
97 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 97
98 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 98
99 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 99
100 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 100
101 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 101
102 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 102
103 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 103
104 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 104
105 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 105
106 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 106
107 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 107
108 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 108
109 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 109
110 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 110
111 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 111
112 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 112
113 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 113
114 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 114
115 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 115
116 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; verdadeiro, pois 'e' 'o' while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 116
117 'a''n''e''m''o''n''a''\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 117
118 '\0' p int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 118
119 '\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 119
120 '\0' p q int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 120
121 '\0' q p int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 121
122 '\0' q p int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 122
123 '\0' q p int palindromo(const char *p) { const char *q = p; while (*q!= '\0') ++q; --q; while (p < q) { if (*p!= *q) return 0; ++p; --q; return 1; 123
124 PASSAGEM DE PARÂMETROS Crie o arquivo incrementa.c void incrementa(int i) { ++i; Teste no cling:.l incrementa.c 124
125 PASSAGEM DE PARÂMETROS Crie o arquivo incrementa.c void incrementa(int i) { ++i; Teste no cling:.l incrementa.c int i = 0; 125
126 PASSAGEM DE PARÂMETROS Crie o arquivo incrementa.c void incrementa(int i) { ++i; Teste no cling:.l incrementa.c int i = 0; incrementa(i) 126
127 PASSAGEM DE PARÂMETROS Crie o arquivo incrementa.c void incrementa(int i) { ++i; Teste no cling:.l incrementa.c int i = 0; incrementa(i) 127
128 PASSAGEM DE PARÂMETROS Crie o arquivo incrementa.c void incrementa(int i) { ++i; Teste no cling:.l incrementa.c int i = 0; incrementa(i) i 128
129 PASSAGEM DE PARÂMETROS Crie o arquivo incrementa.c void incrementa(int i) { ++i; Teste no cling: (int) 0.L incrementa.c int i = 0; incrementa(i) i 129
130 PASSAGEM DE PARÂMETROS Crie o arquivo incrementa.c void incrementa(int i) { ++i; Teste no cling: (int) 0.L incrementa.c int i = 0; incrementa(i) i POR QUE VOCÊ FAZ ISSO COMIGO, C!?!?!!!!!11!!UM!! 130
131 PASSAGEM DE PARÂMETROS void incrementa(int i) { ++i; Em C, a passagem de parâmetros para uma função é sempre por valor, ou seja, quando passamos uma variável para uma função, o valor dessa variável é copiado para o parâmetro correspondente. Se quisermos alterar uma variável passada como parâmeto, temos que passar uma referência a ela. 131
132 PASSAGEM DE PARÂMETROS Corrija o arquivo incrementa.c void incrementa(int *i) { ++(*i); Reinicie o cling e teste:.l incrementa.c 132
133 PASSAGEM DE PARÂMETROS Corrija o arquivo incrementa.c void incrementa(int *i) { ++(*i); Reinicie o cling e teste:.l incrementa.c int i = 0; 133
134 PASSAGEM DE PARÂMETROS Corrija o arquivo incrementa.c void incrementa(int *i) { ++(*i); Reinicie o cling e teste:.l incrementa.c int i = 0; incrementa(&i) 134
135 PASSAGEM DE PARÂMETROS Corrija o arquivo incrementa.c void incrementa(int *i) { ++(*i); Reinicie o cling e teste:.l incrementa.c int i = 0; incrementa(&i) 135
136 PASSAGEM DE PARÂMETROS Corrija o arquivo incrementa.c void incrementa(int *i) { ++(*i); Reinicie o cling e teste:.l incrementa.c int i = 0; incrementa(&i) i 136
137 PASSAGEM DE PARÂMETROS Corrija o arquivo incrementa.c void incrementa(int *i) { ++(*i); Reinicie o cling e teste: (int) 1.L incrementa.c int i = 0; incrementa(&i) i 137
138 PASSAGEM DE PARÂMETROS Crie o arquivo ordena.c Implemente a função de nome troca, que troca os valores de duas variáveis do tipo int. Exemplo de uso no cling:.l ordena.c int x = 42, y = 99; troca(&x, &y); x (int) 99 y (int)
139 ORDENAÇÃO POR BORBULHAMENTO (bubble sort) Entrada: array A de int Resultado: ordena A em ordem crescente enquanto houver par de elementos A[i], A[i+1] tal que A[i] > A[i+1] (onde i = 0 n-2) troca A[i] com A[i+1] Ordenação in-place: o próprio array é ordenado, sem criação de outro array auxiliar. 139
140 ORDENAÇÃO POR BORBULHAMENTO (bubble sort) Implemente no arquivo ordena.c: void bubblesort(int *a, int n) Use a função troca. Teste no cling:.l ordena.c int v[] = { 42, 18, 99, -1, 3 ; bubblesort(v, 5); v 140
141 ORDENAÇÃO POR BORBULHAMENTO (bubble sort) Implemente no arquivo ordena.c: void bubblesort(int *a, int n) Use a função troca. Teste no cling:.l ordena.c int v[] = { 42, 18, 99, -1, 3 ; bubblesort(v, 5); v (int [5]) { -1, 3, 18, 42,
Programação Estruturada Prof. Rodrigo Hausen Organização e Gerenciamento de Memória
Programação Estruturada Prof. Rodrigo Hausen http://progest.compscinet.org Organização e Gerenciamento de Memória 1 AULA PASSADA - vetores ou arrays Declaração de um vetor (array) em C: tipo nome[tamanho];
Programação Estruturada Prof. Rodrigo Hausen Agregados de Dados Heterogêneos (structs)
Programação Estruturada Prof. Rodrigo Hausen http://progest.compscinet.org Agregados de Dados Heterogêneos (structs) 1 AGREGADO HOMOGÊNEO Um agregado homogêneo de dados é um conjunto de dados que são necessariamente
Estruturas de Dados. Introdução Definição de Ponteiros Declaração de Ponteiros em C Manipulação de Ponteiros em C
Estruturas de Dados Revisão de Ponteiros Prof. Ricardo J. G. B. Campello Sumário Introdução Definição de Ponteiros Declaração de Ponteiros em C Manipulação de Ponteiros em C Operações Ponteiros e Arranjos
Ponteiros e alocação dinâmica de memória. Disciplina de Programação de Computadores I Universidade Federal de Ouro Preto
Ponteiros e alocação dinâmica de memória Disciplina de Programação de Computadores I Universidade Federal de Ouro Preto Agenda Ponteiros Ponteiros e vetores Passagem por cópia e por referência Alocação
1 Exercícios com ponteiros
Computação para Informática Funções e Ponteiros1 EXERCÍCIOS COM PONTEIROS Computação para Informática - Prof. Adriano Joaquim de Oliveira Cruz Aula Prática - Funções e ponteiros O objetivo desta aula prática
Programação Estruturada Prof. Rodrigo Hausen Vetores (Arrays)
Programação Estruturada Prof. Rodrigo Hausen http://progest.compscinet.org Vetores (Arrays) 1 AULA PASSADA - CONDICIONAIS Exercício 1: Crie a função vlrabs que recebe um double e retorna o seu valor absoluto.
A sintaxe para se declarar uma variável do tipo ponteiro é dada por:
Pense duas vezes e faça uma vez. Provérbio Chinês. PONTEIROS Um ponteiro nada mais é que uma variável capaz de armazenar um número hexadecimal que corresponde a um endereço de memória de outra variável.
Aula 17: Ponteiros e Alocação Dinâmica em C
Aula 17: Ponteiros e Alocação Dinâmica em C Fernanda Passos Universidade Federal Fluminense Programação de Computadores IV Fernanda Passos (UFF) Ponteiros e Alocação Dinâmica Programação de Computadores
Introdução a Programação. Ponteiros e Vetores, Alocação Dinâmica
Introdução a Programação Ponteiros e Vetores, Alocação Dinâmica Tópicos da Aula Hoje aprenderemos que existe uma forte relação entre ponteiros e vetores Associação entre ponteiros e vetores Ponteiros constantes
Aula 25: Alocação Dinâmica
Aula 25: Alocação Dinâmica Introdução a Programação Túlio Toffolo & Puca Huachi http://www.toffolo.com.br BCC201 2019/1 Departamento de Computação UFOP Aulas anteriores Estruturas de memórias heterogêneas
Ponteiros. Introdução
Ponteiros Introdução Conceito Um PONTEIRO ou APONTADOR é uma variável usada para armazenar um endereço de memória. Normalmente, o endereço armazenado em um PONTEIRO é a posição de uma outra variável na
Ponteiros e Tabelas. K&R: Capítulo 5
Ponteiros e Tabelas K&R: Capítulo 5 Ponteiros e Tabelas Ponteiros e endereços Ponteiros e argumentos de funções Ponteiros e tabelas Alocação dinâmica de memória Aritmética de ponteiros Tabelas de ponteiros
Exercícios sobre textos; Alocação dinâmica.
s sobre textos; Alocação dinâmica. David Deharbe 1 1 s Escreva uma sub-rotina, chamada strchr, que recebe um string s (= o endereço onde está guardado um texto), um caracter c e retorna o endereço da primeira
Linguagem C. Ponteiros. Alex Vidigal Bastos.
Linguagem C Ponteiros Alex Vidigal Bastos alexvbh@gmail.com Ponteiros Ponteiros são variáveis que contém endereços. Estas variáveis apontam para algum determinado endereço da memória. Em geral, o ponteiro
Instituto Federal da Bahia Análise e Desenvolvimento de Sistemas INF029 Laboratório de Programação Aula 03: Ponteiros
Instituto Federal da Bahia Análise e Desenvolvimento de Sistemas INF029 Laboratório de Programação Aula 03: Ponteiros Prof. Dr. Renato L. Novais renato@ifba.edu.br Agenda Ponteiros Slide 2/TN Roteiro Ponteiros
Ponteiros e Alocação de Memória
Algoritmos e Estrutura de Dados I Ponteiros e Alocação de Memória Prof. Paulo Henrique Pisani fevereiro/2019 Memória Podemos entender a memória como um grande vetor de bytes devidamente endereçados: 0x1051
Programação II. Vetores e Alocação Dinâmica. Bruno Feijó Dept. de Informática, PUC-Rio
Programação II Vetores e Alocação Dinâmica Bruno Feijó Dept. de Informática, PUC-Rio Vetores (arrays) Vetor: estrutura de dados definindo um conjunto enumerável Exemplo: v = vetor de inteiros com 10 elementos
ALGORITMOS E ESRUTRA DE DADOS I. Ponteiros Passagem por Valor e Referência Alocação de Memória
ALGORITMOS E ESRUTRA DE DADOS I Ponteiros Passagem por Valor e Referência Alocação de Memória 2 Agenda Ponteiros Conceitos gerais O que é Ponteiro? Declaração de Ponteiros Operadores para Ponteiros Exemplos
Ponteiros e Tabelas. K&R: Capitulo 5 IAED, 2012/2013
Ponteiros e Tabelas K&R: Capitulo 5 Ponteiros e Tabelas Ponteiros e endereços Ponteiros e argumentos de funções Ponteiros e tabelas Alocação dinâmica de memória Aritmética de ponteiros Tabelas de ponteiros
Ponteiros e Tabelas. K&R: Capitulo 5 IAED, 2012/2013
Ponteiros e Tabelas K&R: Capitulo 5 Ponteiros e Tabelas Ponteiros e endereços Ponteiros e argumentos de funções Ponteiros e tabelas Alocação dinâmica de memória Aritmética de ponteiros Tabelas de ponteiros
INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA RIO GRANDE DO NORTE
INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA RIO GRANDE DO NORTE Algoritmos ANSI C - Gerenciamento de Memória Copyright 2014 IFRN Agenda Introdução Alocação dinâmica Funções malloc free calloc realloc
O que é um apontador em C (type pointer in C)?
O que é um apontador em C (type pointer in C)? Um apontador é uma variável que contém um endereço de outra variável. int x = 10;//variável inteira iniciada com o valor 10 int *px = &x;//variável apontadora
Programação Estruturada
Programação Estruturada Ponteiros Parte 1 Professores Emílio Francesquini e Carla Negri Lintzmayer 2018.Q3 Centro de Matemática, Computação e Cognição Universidade Federal do ABC Ponteiros Ponteiro Ponteiros
Centro Universitário Franciscano Curso de Sistemas de Informação Disciplina de algoritmos e programação II. Ponteiros
Centro Universitário Franciscano Curso de Sistemas de Informação Disciplina de algoritmos e programação II Ponteiros Profa.: Simone Ceolin Slides (Prof.Tiago Rios da Rocha) Primeiro Semestre 2011 Sumário
INF 1007 Programação II
INF 1007 Programação II Aula 04 Alocação Dinâmica Edirlei Soares de Lima Vetores - Declaração e Inicialização Declaração de um vetor: int meu_vetor[10]; Reserva um espaço de memória
1 Exercícios com ponteiros
Computação para Informática - Prof. Adriano Joaquim de Oliveira Cruz Oitava Aula Prática - 29 de outubro de 2010 O objetivo desta aula prática é exercitar ponteiros e funções. 1 Exercícios com ponteiros
Exercício. Alocação Dinâmica. Alocação dinâmica de memória. Alocação de memória. Alocação da Memória Principal. Alocação da Memória Principal
Exercício Crie uma função que recebe o número de dias até um determinado evento e calcula e retorna o equivalente em meses, semanas e dias, sem usar vetor ou o conceito de vetor. Considerar que todos os
11a. Aula Ponteiros e Vetores
11a. Aula Ponteiros e Vetores 2013.2 2 É um tipo de variável com uma ressalva...... armazena apenasendereçode memória (ou null) Se eu tiver o endereço da casa de Francisca, eu poderei visitá-la e lhe fazer
Ponteiros. Baseado nos slides do Prof. Mauro.
Baseado nos slides do Prof. Mauro. A memória do computador é uma sequência de bytes, na qual endereçamos cada um sequencialmente. Como vimos, uma variável é uma região da memória que reservamos para armazenar
Ponteiros - Parte I. Ponteiros, Ponteiros e Vetores, Algoritmo Bubble Sort, Alocação Dinâmica de Memória
Ponteiros - Parte I Ponteiros, Ponteiros e Vetores, Algoritmo Bubble Sort, Alocação Dinâmica de Memória Ponteiros Um ponteiro é uma variável que contém um endereço de memória. Esse endereço é normalmente
Sumário. Introdução à Ciência da Computação. Ponteiros em C. Introdução. Definição. Por quê ponteiros são importantes?
Introdução à Ciência da Computação Ponteiros em C Prof. Ricardo J. G. B. Campello Sumário Introdução Definição de Ponteiros Declaração de Ponteiros em C Manipulação de Ponteiros em C Operações Ponteiros
Alocação Dinâmica em C
Universidade de São Paulo São Carlos Instituto de Ciências Matemáticas e de Computação Alocação Dinâmica em C Profa Rosana Braga Adaptado de material preparado pela profa Silvana Maria Affonso de Lara
Ponteiros e Alocação Dinâmica em C. Fonte: DCC UFMT (modificado)
Ponteiros e Alocação Dinâmica em C Fonte: DCC UFMT (modificado) Definições Variáveis : endereçam uma posição de memória que contem um determinado valor dependendo do seu tipo (char, int, float, double,...)
Computação 2. Aula 7. Profª. Fabiany Ponteiros
Computação 2 Aula 7 Ponteiros Profª. Fabiany fabianyl@utfpr.edu.br O que são Ponteiros? Um ponteiro é uma variável que contém um endereço de memória. Este endereço é normalmente a posição de uma outra
Programação Computacional Aula 16: Alocação Dinâmica de Memória
Programação Computacional Aula 16: Alocação Dinâmica de Memória Profa. Madeleine Medrano madeleine@icte.uftm.edu.br Definição Sempre que escrevemos um programa, é preciso reservar espaço para as informações
Curso de Programação C em Ambientes Linux Aula 05
Curso de Programação C em Ambientes Linux Aula 05 Centro de Engenharias da Mobilidade - UFSC Professores Gian Berkenbrock e Giovani Gracioli http://www.lisha.ufsc.br/c+language+course+resources Conteúdo
Ponteiros. Prof. Fernando V. Paulovich *Baseado no material do Prof. Gustavo Batista
Ponteiros SCC0202 - Algoritmos e Estruturas de Dados I Prof. Fernando V. Paulovich *Baseado no material do Prof. Gustavo Batista http://www.icmc.usp.br/~paulovic paulovic@icmc.usp.br Instituto de Ciências
Estruturas de Dados Aulas 3 e 4: Uso da. 14/03/2011 e 16/03/2011
Estruturas de Dados Aulas 3 e 4: Uso da memória e Vetores 14/03/2011 e 16/03/2011 Uso da memória Existem 3 maneiras de reservar o espaço da memória: Variáveis globais (estáticas) Espaço existe enquanto
Tipos Abstratos de Dados. Estrutura de Dados
Tipos Abstratos de Dados Tipo Abstrato de Dados ou TAD Idéia principal: desvincular o tipo de dado (valores e operações) de sua implementação: O que o tipo faz e não como ele faz! Vantagens da desvinculação:
Computadores Digitais 2. Prof. Rodrigo de Souza Couto
Computadores Digitais 2 Linguagens de Programação DEL-Poli/UFRJ Prof. Miguel Campista Aula de Hoje Vetores e alocação dinâmica Vetores Alocação dinâmica Vetores locais e funções ATENÇÃO Esta apresentação
DAS5102 Fundamentos da Estrutura da Informação
Ponteiros e Funções Funções ou sub-rotinas são parcelas de código que podem ser invocadas a partir do programa principal ou até mesmo por outras sub-rotinas. Elas têm como objetivo a execução de uma tarefa
BCC202 - Estrutura de Dados I
BCC202 - Estrutura de Dados I Aula 02: Alocação Dinâmica de Memória Reinaldo Fortes Universidade Federal de Ouro Preto, UFOP Departamento de Ciência da Computação, DECOM Website: www.decom.ufop.br/reifortes
Estruturas de Dados. Profa. Juliana Pinheiro Campos
Estruturas de Dados Profa. Juliana Pinheiro Campos Vetores Forma mais simples de estruturar um conjunto de dados. Exemplo: int p[10]; // vetor de inteiros com 10 elementos Reserva de um espaço de memória
Programação II. Vetores e Alocação Dinâmica. Bruno Feijó Dept. de Informática, PUC-Rio
Programação II Vetores e Alocação Dinâmica Bruno Feijó Dept. de Informática, PUC-Rio Vetores (arrays) Vetor: estrutura de dados definindo um conjunto enumerável Exemplo: v = vetor de inteiros com 10 elementos
Bruno Hott Algoritmos e Estruturas de Dados I DECSI UFOP. Alocação Dinâmica de Memória
Bruno Hott Algoritmos e Estruturas de Dados I DECSI UFOP Alocação Dinâmica de Memória Alocação Estática x Dinâmica C: dois tipos de alocação de memória: Estática e Dinâmica Na alocação estática, o espaço
Ponteiros em C. Prof. Rui Jorge Tramontin Jr. UDESC - Rui J. Tramontin Jr. 1
Ponteiros em C Prof. Rui Jorge Tramontin Jr. UDESC - Rui J. Tramontin Jr. 1 Índice Introdução Operações sobre Ponteiros Exemplos Ponteiros e Funções Alocação Dinâmica em C UDESC - Rui J. Tramontin Jr.
Ponteiros e Alocação Dinâmica. Prof. Péricles Miranda
Ponteiros e Alocação Dinâmica Prof. Péricles Miranda pbcm@cin.ufpe.br Memória A memória é formada por várias células. Cada célula contém um endereço e um valor. Memória Endereço Ao declararmos uma variável
Estruturas de Dados Aulas 3 e 4: Uso da memória e Vetores
Estruturas de Dados Aulas 3 e 4: Uso da memória e Vetores Uso da memória Existem 3 maneiras de reservar o espaço da memória: Variáveis globais (estáticas) Espaço existe enquanto programa estiver executando
ponteiros INF Programação I Prof. Roberto Azevedo
ponteiros INF1005 -- Programação I -- 2016.1 Prof. Roberto Azevedo razevedo@inf.puc-rio.br ponteiros tópicos o que são ponteiros operadores usados com ponteiros passagem de ponteiros para funções referência
Ponteiros. um ponteiro é uma variável que contém o endereço um dado declaração: * indica que a variável é um ponteiro. Ex: tipo_dado *nome_ponteiro;
Ponteiros um ponteiro é uma variável que contém o endereço um dado declaração: * indica que a variável é um ponteiro Ex: tipo_dado *nome_ponteiro; /* compilador sabe que pi é ponteiro */ /* pi é um ponteiro
Exercícios. Alocação Dinâmica. Alocação dinâmica de memória. Alocação de memória. Alocação da Memória Principal. Alocação da Memória Principal
Exercícios 1) Crie uma função que recebe os coeficientes de uma função do 2o. grau e retorna as raízes sem usar vetor. 2) Faça um programa que acha o maior e o menor inteiro dentro de um vetor de 10 inteiros,
13. ALOCAÇÃO DINÂMICA DE MEMÓRIA
787878787878787878787878787878787878787878787878787878 13. ALOCAÇÃO DINÂMICA DE MEMÓRIA Sempre é necessário declarar o número de elementos do array. Mas e se ele for desconhecido? E se ele variar? Pode
Alocação Dinâmica de Memória
Alocação Dinâmica de Memória Luiz Chaimowicz, Raquel O. Prates, Pedro O.S. Vaz de Melo Algoritmos e Estruturas de Dados II DCC UFMG Alocação Estática x Dinâmica C: dois tipos de alocação de memória: Estática
SSC304 Introdução à Programação Para Engenharias. Alocação Dinâmica. GE4 Bio
Universidade de São Paulo Instituto de Ciências Matemáticas e de Computação Departamento de Sistemas de Computação Introdução à Para Engenharias GE4 Bio GE4Bio Grupo de Estudos em Sinais Biológicos Prof.Dr.
Alocação Dinâmica. Introdução à Computação
Alocação Dinâmica Introdução à Computação Alocação de memória Uso da memória: uso de variáveis globais (e está>cas): O espaço reservado para uma variável global existe enquanto o programa es>ver sendo
Módulo 5 Vetores e Alocação Dinâmica
Estruturas de Dados Módulo 5 Vetores e Alocação Dinâmica 1/9/2005 (c) Dept. Informática - PUC-Rio 1 Referências Waldemar Celes, Renato Cerqueira, José Lucas Rangel, Introdução a Estruturas de Dados, Editora
Introdução à Programação
Introdução à Programação Aula 08 Ponteiros Edirlei Soares de Lima Endereço de uma Variável Toda variável definida em um programa ocupa uma área de memória; A cada área de memória
Estruturas Dinâmicas - Ponteiros
SSC0800 - ICC1 Teórica Introdução à Ciência da Computação I Estruturas Dinâmicas - Ponteiros Prof. Claudio Fabiano Motta Toledo: claudio@icmc.usp.br Sumário Ponteiros Ponteiros e Vetores Funções para alocação
Aula 24 Ponteiros, vetores e structs
Programação Aula 24 Ponteiros, vetores e structs Prof. Laura Silva de Assis Engenharia de Computação 2 o Período CEFET/RJ - Centro Federal de Educação Tecnológica Celso Suckow da Fonseca UnED Petrópolis
Programação II. Vetores Bidimensionais e Vetores de Ponteiros. Bruno Feijó Dept. de Informática, PUC-Rio
Programação II Vetores Bidimensionais e Vetores de Ponteiros Bruno Feijó Dept. de Informática, PUC-Rio Array (Vetor) Bidimensional 0 0 1 2 3 4 5 6 7 8 14 1 2 Array (Vetor) Bidimensional vs Ponteiros Quando
Princípios de Desenvolvimento de Algoritmos MAC122
Princípios de Desenvolvimento de Algoritmos MAC122 Prof. Dr. Paulo Miranda IME-USP Alocação Dinâmica de Memória Motivação: Nossos programas pré-fixavam o número de variáveis a serem utilizadas. No caso
Fundamentos de Programação
Fundamentos de Programação CP41F Aula 12 Prof. Daniel Cavalcanti Jeronymo Layout de memória. Ponteiros: conceito, operadores de referência e dereferência, operações, aritmética e indireção múltipla Universidade
Ponteiros. Introdução e Alocação Dinâmica
Ponteiros Introdução e Alocação Dinâmica Conceito Um PONTEIRO ou APONTADOR é uma variável usada para armazenar um endereço de memória. Normalmente, o endereço armazenado em um PONTEIRO é a posição de uma
Ponteiros. Ponteiros. Ponteiros. Ponteiros. Ponteiros. Introdução a Programação. Profa. Roseli Romero
ICMC USP 1.semestre/2009 Introdução a Programação e vetores em C Profa. Roseli Romero um é uma variável que contém o endereço um dado declaração: * indica que a variável é um tipo_dado *nome_; int x; int
Caracteres e Strings
Caracteres e Strings String em C É um array de elementos do tipo char terminado pelo caractere nulo Caractere nulo: '\0' Valor zero em qualquer código de caracteres Strings são essenciais em qualquer programa
Gilberto A. S. Segundo. 24 de agosto de 2011
Exercícios - Alocação Dinâmica Gilberto A. S. Segundo Programação Aplicada de Computadores Engenharia Elétrica Universidade Federal do Espírito Santo - UFES 24 de agosto de 2011 1 / 23 Grupo de e-mail
Computadores Digitais 2. Prof. Rodrigo de Souza Couto
Computadores Digitais 2 Linguagens de Programação DEL-Poli/UFRJ Prof. Miguel Campista Tópicos Listas Encadeadas Introdução às listas encadeadas Manipulação de elementos Implementações recursivas Listas
AULA 6. Conceitos. Melhores momentos. Conceitos. Conceitos. Conceitos. Conceitos
Melhores momentos AULA Endereços: a memória é um vetor e o índice desse vetor onde está uma variável é o endereço da variável. Com o operador & obtemos o endereço de uma variável. Exemplos: &i é o endereço
Universidade Federal de Uberlândia Faculdade de Computação. Linguagem C: ponteiros e alocação dinâmica
Universidade Federal de Uberlândia Faculdade de Computação Linguagem C: ponteiros e alocação dinâmica Prof. Renato Pimentel 1 Ponteiros 2 Prof. Renato Pimentel 1 Ponteiros: introdução Toda a informação
Mais sobre Ponteiros em C
Universidade de São Paulo São Carlos Instituto de Ciências Matemáticas e de Computação Mais sobre Ponteiros em C Material preparado pela profa Silvana Maria Affonso de Lara 2º semestre de 2010 ROTEIRO
Algoritmos e Estruturas de Dados. Prof. Marcelo Zorzan Profa. Melissa Zanatta
Algoritmos e Estruturas de Dados Prof. Marcelo Zorzan Profa. Melissa Zanatta Assuntos da Aula Alocação de Memória Alocação estática de memória Alocação dinâmica de memória Malloc, Calloc, Free, Realloc
prim = A ; prim = &A[0];
![prim = A ; prim = &A[0];](/thumbs/96/127433262.jpg "prim = A ; prim = &A[0];")
57 12 - MAIS SOBRE APONTADOR 12.1 - Ponteiros e arrays Em C, ponteiros e matrizes são tratados de maneira semelhante. 12.1.1 - Nome O nome é um ponteiro, ou seja, aponta (contém o endereço) para o primeiro
Ponteiro. Ponteiro. Objetivo. Compreender a definição e dominar a implementação de ponteiros em C.
Ponteiro Definição de variável apontadora Aritmética de ponteiros Ponteiros e vetores Funções e passagem por referência Structs e ponteiros Alocação dinâmica de memória Objetivo Ponteiro Ponteiro Compreender
INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA RIO GRANDE DO NORTE
INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA RIO GRANDE DO NORTE Algoritmos ANSI C - Ponteiros Copyright 2014 IFRN Agenda Memória Ponteiros Aritmética de ponteiros Arrays/strings Parâmetros de função
REVISÃO DE C. Vanessa Braganholo Estruturas de Dados e Seus Algoritmos
REVISÃO DE C Vanessa Braganholo Estruturas de Dados e Seus Algoritmos REVISÃO DE C Ponteiros Alocação dinâmica de memória Recursão INSTITUTO DE COMPUTAÇÃO - UFF 2 PONTEIROS PONTEIROS C permite o armazenamento
Alocação Dinâmica de Memória. Programação II
Alocação Dinâmica de Memória Programação II Alocação dinâmica Uso da memória Uso de variáveis globais (e estáticas): Espaço reservado para uma variável global existe enquanto o programa estiver sendo executado.
Funções em Linguagem C Parte II
Slides inicialmente preparados pelo Prof. Dr. Claudio Fabiano Motta Toledo Funções em Linguagem C Parte II Profa. Dra. Elisa Yumi Nakagawa 1. Semestre 2017 Sumário Introdução a Ponteiros Escopo de Variáveis
Aula 27: Estruturas heterogêneas e alocação dinâmica
Aula 27: Estruturas heterogêneas e alocação dinâmica Introdução a Programação Túlio Toffolo & Puca Huachi http://www.toffolo.com.br BCC201 2018/2 Departamento de Computação UFOP Aulas anteriores Memória
Ponteiros. prof. Fabrício Olivetti de França
Ponteiros prof. Fabrício Olivetti de França Anteriormente em prog. estrut. Vimos que as variáveis representando arrays em C armazenam apenas um apontador para o endereço de memória contendo os valores
Linguagem de Programação C. Ponteiros
Cristiano Lehrer Conceitos Básicos (1/3) char ch; RAM 100 101 102... 5000 5001 5002... ch ch = 'A'; RAM ch A 100 101 102... 5000 5001 5002... char *; RAM ch A 100 101 102... 5000 5001 5002... = &ch; ch
LINGUAGEM C: ALOCAÇÃO DINÂMICA
LINGUAGEM C: ALOCAÇÃO DINÂMICA Prof. André Backes DEFINIÇÃO Sempre que escrevemos um programa, é preciso reservar espaço para as informações que serão processadas. Para isso utilizamos as variáveis Uma
Reinaldo Gomes Alocação Dinâmica
Algoritmos e Lógica de Programação Linguagem C Alocação Dinâmica i de Memória Reinaldo Gomes reinaldo@cefet-al.br Alocação Dinâmica Quando declaramos uma variável ou um arranjo, o compilador automaticamente
MC-102 Aula 19 Ponteiros II
MC-102 Aula 19 Ponteiros II Instituto de Computação Unicamp 20 de Outubro de 2016 Roteiro 1 Ponteiros e Alocação Dinâmica 2 Exemplo de Alocação Dinâmica de Vetores 3 Erros Comuns ao Usar Alocação Dinâmica
Métodos Computacionais. Vetores e Matrizes Dinâmicas
Métodos Computacionais Vetores e Matrizes Dinâmicas Vetores Um programa para o cálculo da média Média m n i= = 1 n x i Variância v n i= = 1 ( x i n m) 2 A forma mais simples de estruturar um conjunto de
Fundamentos de Programação
Fundamentos de Programação ET42G Aula 21 Prof. Daniel Cavalcanti Jeronymo Conversão de tipos. Alocação dinâmica de memória. Recursão. Criação de bibliotecas, arquivos de cabeçalhos e variáveis globais.
13/11/15. Incrementando C: C++ E na especificação de BigInt... Arquitetura da solução exemplo. O arquivo de declarações. Explorando a classe BigInt
Incrementando C: permite: Definir uma classe para números grandes; Manter o código bem parecido com o programa C. O mesmo programa em C (e até mesmo em Java) não são tão convenientes e elegantes. #include
Introdução à Ciência da Computação I. Alocação Dinâmica. Prof. Claudio Fabiano Motta Toledo
Introdução à Ciência da Computação I Alocação Dinâmica Prof. Claudio Fabiano Motta Toledo Sumário Funções para alocação de memória Ponteiros para ponteiros 8/12/16 2 Funções para alocação de memória malloc(),
Essencialmente, um ponteiro nada mais é do que uma variável que ao invés de conter um valor, contém um endereço de memória.
Ponteiros e Arrays Ponteiros são fundamentais para a programação bem sucedida em C: Passagem de parâmetros por referência; Alocação dinâmica de memória; Aumentar a eficiência de certar rotinas. Essencialmente,
TÉCNICAS DE LINGUAGEM DE PROGRAMAÇÃO
TÉCNICAS DE LINGUAGEM DE PROGRAMAÇÃO Ponteiros Definição Variável: área de memória que armazena dados de um certo tipo. Na memória, toda variável possui um endereço. Um Ponteiro é uma variável especial
Introdução à Computação
Introdução à Computação Linguagem C Professor: André de Carvalho Aula de hoje Introdução Tipos compostos Tipo enumeração Conclusão Tipos compostos A Linguagem C permite criar tipos de dados definíveis
Linguagem C ponteiros
Linguagem C ponteiros IF61A/IF71A - Computação 1 Prof. Leonelo Almeida Universidade Tecnológica Federal do Paraná Até agora... Introdução à linguagem C... Vetores Matrizes Funções Recursão Registros Aula
Professora Jeane Melo
Professora Jeane Melo Roteiro Lista Encadeada Alocação: Estática x Dinâmica O que são Ponteiros? Ponteiros Variáveis que Armazenam Endereços de Memória Mas, toda variável não é armazenada na memória? Ponteiros
Laboratório de Introdução à Ciência da Computação I
Laboratório de Introdução à Ciência da Computação I Aula 12 Alocação dinâmica de memória Professor: Jó Ueyama Estagiária PAE: Aurea Soriano slide 1 Funções para alocação de memória malloc(), calloc(),
Aula 18: Funções em C
Aula 18: Funções em C Fernanda Passos Universidade Federal Fluminense Programação de Computadores IV Fernanda Passos (UFF) Funções em C Programação de Computadores IV 1 / 38 Agenda 1 Revisão e Contexto
Plano de Aula Segunda-feira Tarde 13/10/2014 Objetivo: Introduzir o conceito de alocação dinâmica na memória e registros / structs.
Instituto Federal de Santa Catarina - Câmpus Chapecó Ensino Médio Integrado em Informática - Módulo IV Unidade Curricular: Programação Estruturada Professora: Lara Popov Zambiasi Bazzi Oberderfer Plano
Modulo 12: alocação dinâmica de memória
PROGRAMAÇÃO DE COMPUTADORES V - TCC- 00.323 Modulo 12: alocação dinâmica de memória Aura - Erick aconci@ic.uff.br, erickr@id.uff.br Roteiro porque e como utilizar a alocação dinâmica funções: malloc (
Estrutura de dados 1. Ponteiros
Estrutura de dados 1 Ponteiros Ponteiros Um ponteiro é um endereço de memória O valor de um ponteiro indica onde uma variável está armazenada Um ponteiro proporciona um modo de acesso a uma variável sem