DHD – Desenvolvimento em Hardware quarta-feira, 24 de abril de 2019

DHD – Desenvolvimento em Hardware Prof. Frederico Brito Fernandes 13 DHD – Desenvolvimento em Hardware Ponteiros: Parte II Ponteiros e Vetores Ponteiros para Estruturas Aritmética de Ponteiros Prof. Frederico Brito Fernandes unibratec@fredbf.com quarta-feira, 24 de abril de 2019

A variável vetor é na verdade, o endereço da primeira posição do vetor (1) Ponteiros e Vetores O vetor é um ponteiro... Ponteiro esse que aponta para a primeira posição do vetor Vejamos como o compilador interpreta o exemplo abaixo: (suponha que um inteiro seja armazenado em 2 bytes) Ex: int vetor[10] = {2,3,0}; // O compilador reserva 20 bytes seqüenciais vetor [100] [102] [104] [106] [108] [110] [112] [114] [116] [118] 2 3 ? 1 2 3 4 5 6 7 8 9 A variável vetor é na verdade, o endereço da primeira posição do vetor Ex: vetor[0] = 4 é equivalente a *vetor = 4; //veja se vc entende bem isso!

O endereço da primeira posição do vetor é dado por: (1) Ponteiros e Vetores O endereço da primeira posição do vetor é dado por: vetor ou &vetor[0] vetor ou &vetor[0] [100] [102] [104] [106] [108] [110] [112] [114] [116] [118] 2 3 ? 1 2 3 4 5 6 7 8 9 Ex: int vetor[10] = {2,3,0}; // o vetor é o endereço do primeiro elemento int *p = vetor; // apesar de não ter ‘&’, o vetor já representa um endereço p = &vetor[2]; printf(“%d”, *p); // que valor é impresso aqui? printf(“%d”, p); // qual valor é impresso aqui agora? p = &vetor[0]; // novamente aponta para o início do vetor p = &vetor; // redundante, mas válido printf(“%d”, *vetor); // qual valor é impresso aqui agora? vetor = &vetor[1]; // Inválido, pois não se altera o endereço de variáveis

(1) Ponteiros e Vetores: auto-avaliação Por que o compilador C é incapaz de checar os limites de um vetor? Olhe o código abaixo: #include <conio.h> typedef struct{ char nome[50]; int idade; } tPessoa; void zeraIdade1(tPessoa pessoa){ pessoa.idade=0; } void zeraIdade2(tPessoa pessoas[]){ pessoas[0].idade=0; main(){ tPessoa pessoas[10] = { {"Fred", 27} }; zeraIdade1(pessoas[0]); printf("A idade da primeira pessoa eh %d\n",pessoas[0].idade); zeraIdade2(pessoas); // equivalente a zeraIdade2(&pessoas[0]); getch(); O que será impresso em (1) e (2)? Explique o porquê! (1) (2)

(2) Ponteiros para estruturas É possível fazer um ponteiro apontar para um tipo de dado estruturado Para acessar o campos desse ponteiro, basta usar o “->”, em vez de “.” Ex: #include <conio.h> typedef struct{ char nome[50]; int idade; } tPessoa, *tPtrPessoa; main(){ tPessoa pessoa = {"Fred",27}; tPessoa *p1 = &pessoa; tPtrPessoa p2 = &pessoa; printf("%s\n",pessoa.nome); printf("Nome: %s\n",p1->nome); printf("Idade: %d\n",p1->idade); p1->idade = 20; getch(); } [100] [108] [112] 100 F r e d \0 27 Ponteiros para tPessoa nome idade pessoa p1 p2 Acessando os campos do ponteiro

(2) Ponteiros para estruturas: auto-avaliação O que será impresso no programa abaixo? #include <stdio.h> #include <string.h> #include <conio.h> typedef struct{ char nome[50]; int idade; } tPessoa; main(){ tPessoa pessoa = {"Fred",27}; tPessoa *p1 = &pessoa; int *p2 = &pessoa.idade; printf("Nome: %s\n",pessoa.nome); printf("Idade: %d\n",pessoa.idade); strcpy(p1->nome,"Zezim"); *p2 = 4; printf("\nNome: %s\n",p1->nome); printf("Idade: %d\n",p1->idade); getch(); } [100] [108] [112] 100 105 F r e d \0 27 nome idade pessoa p1 p2

(2) Ponteiros para estruturas: auto-avaliação Modifique a função zeraIdade() abaixo, para que ela simule uma passagem por referência. Em outras palavras, ela deveria imprimir: "A idade da primeira pessoa eh 0” #include <conio.h> typedef struct{ char nome[50]; int idade; } tPessoa; void zeraIdade(tPessoa pessoa){ pessoa.idade=0; } main(){ tPessoa pessoa = {"Fred", 27}; zeraIdade(pessoa); printf("A idade da primeira pessoa eh %d\n",pessoa.idade); getch(); DICA: Faça a função receber um ponteiro para tPessoa, e modifique o que for necessário

(3) Aritmética de Ponteiros É possível fazer algumas operações com ponteiros: Atribuição: um ponteiro pode ser atribuído a outro Na prática: os dois irão apontar para o mesmo endereço Ex: int *p1, *p2; int vet[5] = {2,3,0}; O que seria fazer? *p2 = *p1; vet [100] [104] [108] [110] [112] [114] [116] ? 2 3 p1 p2 vet[0] vet[1] vet[2] vet[3] vet[4] p1 = &vet[2]; // o ponteiro p1 aponta para o endereço de vet[2] p2 = p1; // o ponteiro p2 vai apontar pra quem p1 aponta [100] [104] [108] [110] [112] [114] [116] 112 2 3 ? p1 p2 vet[0] vet[1] vet[2] vet[3] vet[4]

(3) Aritmética de Ponteiros Um ponteiro pode ser somado com um inteiro: Na prática: o endereço do ponteiro é deslocado de N elementos Ex: int *p1, *p2; int vet[5] = {2,3,0,6,5}; p1 = vet; vet [100] [104] [108] [110] [112] [114] [116] 108 ? 2 3 6 5 p1 p2 vet[0] vet[1] vet[2] vet[3] vet[4] p2=p1+1; // o ponteiro p2 aponta para &vet[0] + 1 (int), ou seja, 110 Atenção: Incrementar o ponteiro aqui não significa somente somar 108 com 1 O ponteiro p2 irá apontar para o elemento (inteiro) seguinte: Se int ocupa 2 bytes, então seria: 108 + (1*2) = 110

(3) Aritmética de Ponteiros Ex: (desenhar no quadro) int *p1, *p2; int vet[5] = {2,3,0,6,5}; p1 = vet; vet [100] [104] [108] [110] [112] [114] [116] 108 ? 2 3 6 5 p1 p2 vet[0] vet[1] vet[2] vet[3] vet[4] p2= p1+2; // o ponteiro p2 aponta para &vet[2], ou seja, 112 // na prática: p1 + 2 = 108 + 2*(2 bytes) = 112 *p1 = *(p2+1); // qual o valor de p1 aqui? vet[1] = *p2; // qual o valor de vet[1]? p2++; // o ponteiro p2 aponta para um elemento posterior // na prática: p2++ = p2+1 = 112 + 1*(2 bytes) = 114 *vetor = *p2 + 1; // aqui, o conteúdo de p2 está sendo somado a 1 *(vetor+1) = 9; // equivalente a usar vet[1] Resumindo: Em C: O conteúdo de um ponteiro pode ser acessado com [ ] *(vet+i) == vet[i] == *(p+i) == p[i]

(3) Aritmética de Ponteiros Refletindo sobre a afirmação: Três programas equivalentes que zeram os elementos de um vetor Em C: O conteúdo de um ponteiro pode ser acessado usando [ ] *(vet+i) == vet[i] == *(p+i) == p[i] 1 2 3 main(){ int vet[5] = {1,2,3,4,5}; int i=0; for(i=0;i<5;i++) vet[i]=0; } main(){ int vet[5] = {1,2,3,4,5}; int i=0; int *p=vet; for(i=0;i<5;i++) p[i]=0; } main(){ int vet[5] = {1,2,3,4,5}; int i=0; int *p=vet; for(i=0;i<5;i++){ *p=0; p++; } Desafio: Você conseguiria explicar o porquê do programa 3 ser mais rápido do que os outros dois?

(3) Aritmética de Ponteiros: auto-avaliação Qual a diferença entre: a) ++p b) *(++p) c) ++(*p) 2. Agora, diga o que seria impresso abaixo: int *p; int vet[5] = {2,4,0,6,5}; p=vet; a) printf(“%d”,++p); b) printf(“%d”,*(++p) ) c) printf(“%d”,++(*p)); Diga o que seria impresso: a) printf(“%d”,p++); b) printf(“%d”,*(p++) ) c) printf(“%d”,(*p)++); vet [100] [104] [106] [108] [110] [112] 104 2 4 6 5 p1 vet[0] vet[1] vet[2] vet[3] vet[4]

(3) Aritmética de Ponteiros: auto-avaliação Um programa em C contém a seguinte declaração: int A[8] = {10, 20, 30, 40, 50, 60, 70, 80} (a) O que representa A? (b) O que representa (A + 2)? (c) Qual é o valor de *A? (d) Qual é o valor de (*A + 2)? (e) Qual é o valor de *(A + 2)? Dadas as seguintes declarações e atribuições: static int ar[] = {10, 15, 4, 1, 3, -4}; int *p; p = &ar[2]; Quais os resultados das avaliações das seguintes expressões: a) *(p + 1); b) p[-1]; c) (ar - p); d) ar[*p++]; e) ar[*++p]; f) *(ar + ar[2]);

(3) Aritmética de Ponteiros: auto-avaliação O que será impresso no programa abaixo? int main() { int y, *p, x; y = 0; p = &y; x = *p; x = 4; (*p)++; x--; (*p) += x; printf ("y = %d\n", y); }