Upload
internet
View
116
Download
4
Embed Size (px)
Citation preview
Professor Aquiles BurlamaquiUERN
A memóriaEndereço Valor
00000000
??
00000001
??
00000002
??
00000003
??
00000004
??
00000005
??
00000006
??
00000007
??
00000008
??
00000009
??
0000000A
??
0000000B
??
0000000C
??
0000000D
??
0000000E
??
0000000F
??
00000010
??
• 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).
Célula
Endereço Valor
0000000D
?? Célula
Variáveis Caracteres
int main() { char i;}
i
• Declaro um caractere chamado i. Os caracteres ocupam 1 bytes na memória(para uma arquitetura de 32 bits).
Endereço Valor
00000000
??
00000001
??
00000002
??
00000003
??
00000004
??
00000005
??
00000006
??
00000007
??
00000008
??
00000009
??
0000000A
??
0000000B
??
0000000C
??
0000000D
??
0000000E
??
0000000F
??
00000010
??
Variáveis Inteiras
int main() { int i;}
i
• Declaro um inteiro chamado i. Os inteiros ocupam 4 bytes na memória(para uma arquitetura de 32 bits)
Endereço Valor
00000000
??
00000001
??
00000002
??
00000003
??
00000004
??
00000005
??
00000006
??
00000007
??
00000008
??
00000009
??
0000000A
??
0000000B
??
0000000C
??
0000000D
??
0000000E
??
0000000F
??
00000010
??
Variáveis Flutuantes
int main() { float i;}
i
• Declaro um número ponto flutuante chamado i. Os flutuantes ocupam 4 bytes na memória(para uma arquitetura de 32 bits)
Endereço Valor
00000000
??
00000001
??
00000002
??
00000003
??
00000004
??
00000005
??
00000006
??
00000007
??
00000008
??
00000009
??
0000000A
??
0000000B
??
0000000C
??
0000000D
??
0000000E
??
0000000F
??
00000010
??
Variáveis Flutuante Longo
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)
Endereço Valor
00000000
??
00000001
??
00000002
??
00000003
??
00000004
??
00000005
??
00000006
??
00000007
??
00000008
??
00000009
??
0000000A
??
0000000B
??
0000000C
??
0000000D
??
0000000E
??
0000000F
??
00000010
??
Declaração de ponteiros
int main() { char* c; int* i; float* f; double d;}
c
• 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.
i
f
d
Endereço Valor
00000000
??
00000001
??
00000002
??
00000003
??
00000004
??
00000005
??
00000006
??
00000007
??
00000008
??
00000009
??
0000000A
??
0000000B
??
0000000C
??
0000000D
??
0000000E
??
0000000F
??
00000010
??
Exemplo 1
int main() { int i; i = 15; char c = ‘s’; int * p = &i; *p = 25; }
i
• Declaro um inteiro chamado i. Os inteiros ocupam 4 bytes na memória(para uma arquitetura de 32 bits)
Endereço Valor
00000000
??
00000001
??
00000002
??
00000003
??
00000004
??
00000005
??
00000006
??
00000007
??
00000008
??
00000009
??
0000000A
??
0000000B
??
0000000C
??
0000000D
??
0000000E
??
0000000F
??
00000010
??
Endereço Valor
00000000
00
00000001
00
00000002
00
00000003
15
00000004
??
00000005
??
00000006
??
00000007
??
00000008
??
00000009
??
0000000A
??
0000000B
??
0000000C
??
0000000D
??
0000000E
??
0000000F
??
00000010
??
Exemplo 1
int main() { int i; i = 15; char c = ‘s’; int * p = &i; *p = 25; }
i
• 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).
Endereço Valor
00000000
00
00000001
00
00000002
00
00000003
15
00000004
s
00000005
??
00000006
??
00000007
??
00000008
??
00000009
??
0000000A
??
0000000B
??
0000000C
??
0000000D
??
0000000E
??
0000000F
??
00000010
??
Exemplo 1
int main() { int i; i = 15; char c = ‘s’; int * p = &i; *p = 25; }
i
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.
Endereço Valor
00000000
00
00000001
00
00000002
00
00000003
15
00000004
s
00000005
00
00000006
00
00000007
00
00000008
00
00000009
??
0000000A
??
0000000B
??
0000000C
??
0000000D
??
0000000E
??
0000000F
??
00000010
??
Exemplo 1
int main() { int i; i = 15; char c = ‘s’; int * p = &i; *p = 25; }
i
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 000000. • Dizemos que p aponta para i.
Endereço Valor
00000000
00
00000001
00
00000002
00
00000003
25
00000004
s
00000005
00
00000006
00
00000007
00
00000008
00
00000009
??
0000000A
??
0000000B
??
0000000C
??
0000000D
??
0000000E
??
0000000F
??
00000010
??
Exemplo 1
int main() { int i; i = 15; char c = ‘s’; int * p = &i; *p = 25; }
i
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.
Exemplo 2
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.
p1
Endereço Valor
00000000
??
00000001
??
00000002
??
00000003
??
00000004
??
00000005
??
00000006
??
00000007
??
00000008
??
00000009
??
0000000A
??
0000000B
??
0000000C
??
0000000D
??
0000000E
??
0000000F
??
00000010
??
Exemplo 2
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.
p1
Endereço Valor
00000000
00
00000001
00
00000002
00
00000003
04
00000004
??
00000005
??
00000006
??
00000007
??
00000008
??
00000009
??
0000000A
??
0000000B
??
0000000C
??
0000000D
??
0000000E
??
0000000F
??
00000010
??
Exemplo 2
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 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.
p1
Endereço Valor
00000000
00
00000001
00
00000002
00
00000003
04
00000004
??
00000005
00
00000006
00
00000007
00
00000008
09
00000009
??
0000000A
??
0000000B
??
0000000C
??
0000000D
??
0000000E
??
0000000F
??
00000010
??
p2
Exemplo 2
int main() { char * p1; p1 = malloc(sizeof(char)); int * p2 = malloc(sizeof(int)*2); *p2 = 55; *(p2+1) = 11;}
• O valor apontado por p2 recebe 55.
p1
Endereço Valor
00000000
00
00000001
00
00000002
00
00000003
04
00000004
??
00000005
00
00000006
00
00000007
00
00000008
09
00000009
00
0000000A
00
0000000B
00
0000000C
55
0000000D
??
0000000E
??
0000000F
??
00000010
??
p2
Exemplo 2
int main() { char * p1; p1 = malloc(sizeof(char)); int * p2 = malloc(sizeof(int)*2); *p2 = 55; *(p2+1) = 11;}
• 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 => 00000009
+ 1 (1 int => 4 bytes)p2+1 0000000D
p1
Endereço Valor
00000000
00
00000001
00
00000002
00
00000003
04
00000004
??
00000005
00
00000006
00
00000007
00
00000008
09
00000009
00
0000000A
00
0000000B
00
0000000C
55
0000000D
00
0000000E
00
0000000F
00
00000010
11
p2
*p2
*(p2+1)
Exemplo 3int 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
00000000
00
00000001
00
00000002
00
00000003
04
00000004
B
00000005
O
00000006
L
00000007
A
00000008
S
00000009
00
0000000A
00
0000000B
00
0000000C
0D
0000000D
F
0000000E
??
0000000F
??
00000010
??
p2
Endereço Valor
00000011
00
00000012
00
00000013
00
00000014
19
00000015
B
00000016
O
00000017
L
00000018
A
p3
Endereço Valor
00000019
F
0000001A
00
0000001B
00
0000001C
04
0000001D
B
0000001E
O
0000001F
L
00000020
A