Professor Aquiles Burlamaqui UERN

Apresentação em tema: "Professor Aquiles Burlamaqui UERN"— Transcrição da apresentação:

1 Professor Aquiles Burlamaqui UERN
Ponteiros

2 A memória Endereço Valor ?? A B C D E F Célula Para um melhor entendimento do uso de ponteiros na linguagem de programação C é imprescindível compreender o seu relacionamento com a memória do computador em que o programa esta executando. A memória é formada por várias células. Cada celular contém um endereço e um valor. O Tamanho do endereço e o tamanho do valor depende da arquitetura do computador (ex: 32 bits ou 64 bits). Endereço Valor D ?? Célula

3 Variáveis Caracteres Endereço Valor ?? A B C D E F i int main() { char i; } Declaro um caractere chamado i. Os caracteres ocupam 1 bytes na memória(para uma arquitetura de 32 bits).

4 Variáveis Inteiras Endereço Valor ?? A B C D E F i int main() { int i; } Declaro um inteiro chamado i. Os inteiros ocupam 4 bytes na memória(para uma arquitetura de 32 bits)

5 Variáveis Flutuantes Endereço Valor ?? A B C D E F i int main() { float i; } Declaro um número ponto flutuante chamado i. Os flutuantes ocupam 4 bytes na memória(para uma arquitetura de 32 bits)

6 Variáveis Flutuante Longo
Endereço Valor ?? A B C D E F int main() { double i; } i Declaro um número ponto flutuante grande chamado i. Os flutuantes ocupam 8 bytes na memória(para uma arquitetura de 32 bits)

7 Declaração de ponteiros
Endereço Valor ?? A B C D E F c int main() { char* c; int* i; float* f; double d; } i Declaração de quatro ponteiros(c,i,f e d). Cada ponteiro de um tipo diferente(char, int, float, double). Todos eles ocupam o mesmo espaço na memória, 4 bytes. Isso acontece porque todos eles armazenam endereços de memória, e o tamanho de um endereço de memória é o mesmo para todos os tipos. f d

8 Exemplo 1 Endereço Valor ?? A B C D E F i int main() { int i; i = 15; char c = ‘s’; int * p = &i; *p = 25; } Declaro um inteiro chamado i. Os inteiros ocupam 4 bytes na memória(para uma arquitetura de 32 bits)

9 Exemplo 1 Endereço Valor 00 15 ?? A B C D E F i int main() { int i; i = 15; char c = ‘s’; int * p = &i; *p = 25; } Faço uma atribuição. A variável i recebe o valor 15. Esse valor 15 é colocado no campo valor da memória alocada previamente para a variável i. Lembrem que essa notação com o 15 na ultima casa é apenas didática na verdade esse valor é armazenado utilizando a notação complemento de 2(tudo em binário).

10 Exemplo 1 Endereço Valor 00 15 s ?? A B C D E F i int main() { int i; i = 15; char c = ‘s’; int * p = &i; *p = 25; } c Variável c do tipo char criada e inicializada com o valor ‘s’. Uma variável do tipo char ocupa 1 byte na memória em nossa arquitetura 32 bits.

11 Exemplo 1 Endereço Valor 00 15 s ?? A B C D E F i int main() { int i; i = 15; char c = ‘s’; int * p = &i; *p = 25; } c p Ponteiro de inteiro declarado. O nome desse ponteiro é p e ele é inicializada no momento de sua criação. O valor que esse ponteiro recebe ao ser inicializado é o endereço da variável i(&i) que nesse caso é o endereço Dizemos que p aponta para i.

12 Exemplo 1 Endereço Valor 00 25 s ?? A B C D E F i int main() { int i; i = 15; char c = ‘s’; int * p = &i; *p = 25; } c p Finalizando, fazemos uma atribuição. Colocamos 25 no valor apontado por p. Como visto no slide anterior p aponta para i. Desse modo, colocamos 25 no valor da variável i.

13 Exemplo 2 Endereço Valor ?? A B C D E F p1 int main() { char * p1; p1 = malloc(sizeof(char)); int * p2 = malloc(sizeof(int)*2); *p2 = 55; *(p2+1) = 11; } Declaração de um ponteiro para char.

14 Exemplo 2 Endereço Valor 00 04 ?? A B C D E F p1 int main() { char * p1; p1 = malloc(sizeof(char)); int * p2 = malloc(sizeof(int)*2); *p2 = 55; *(p2+1) = 11; } O ponteiro p1 recebe o endereço da primeira posição do espaço reservado pela instrução malloc(...). Nesse caso o malloc aloca 1 byte: sizeof(char) é igual a 1. Dizemos que p1 aponta para o byte reservado pelo malloc.

15 Exemplo 2 Endereço Valor 00 04 ?? 09 A B C D E F p1 int main() { char * p1; p1 = malloc(sizeof(char)); int * p2 = malloc(sizeof(int)*2); *p2 = 55; *(p2+1) = 11; } p2 Declaração de um ponteiro para inteiro (p2). Esse ponteiro é inicializado com o valor da primeira posição do espaço alocado pelo malloc. malloc(sizeof(int)*2) aloca 4*2 bytes,ou seja 8 bytes. O espaço equivalente a dois inteiros.

16 Exemplo 2 Endereço Valor 00 04 ?? 09 A B C 55 D E F p1 int main() { char * p1; p1 = malloc(sizeof(char)); int * p2 = malloc(sizeof(int)*2); *p2 = 55; *(p2+1) = 11; } p2 O valor apontado por p2 recebe 55.

17 Exemplo 2 Endereço Valor 00 04 ?? 09 A B C 55 D E F 11 p1 int main() { char * p1; p1 = malloc(sizeof(char)); int * p2 = malloc(sizeof(int)*2); *p2 = 55; *(p2+1) = 11; } p2 A valor apontado por p2+1 recebe 11. Podemos somar ou subtrair do ponteiro. Com isso podemos fazer com o ponteiro aponte não somente para a primeira posição que lhe foi reservado. p2 => + 1 (1 int => 4 bytes) p D *p2 *(p2+1)

18 Exemplo 3 Endereço Valor 00 04 B O L A S A B C 0D D F E ?? F int main() { char * p1 = malloc(sizeof(char)*5); char * p2 = malloc(sizeof(char)); *p2 = ‘F’; p1 = “BOLAS”; char * p3 = malloc(sizeof(char)*6); *p3 = *p2; *(p3+1) = *p1; *(p3+2) = *(p1+1); } p1 ---- Endereço Valor 00 19 B O L A Endereço Valor F A 00 B C 04 D B E O F L A p2 p3