Estrutura de Dados - Ponteiros

Prof. Adriano Teixeira de Souza

 A memória de qualquer computador é uma
seqüência de bytes.

 Cada byte pode armazenar um número
inteiro entre 0 e 255.

 Cada byte na memória é identificado por um
endereço numérico, independente do seu
conteúdo.


Conteúdo Endereço

0000 0001 0x0022FF16

0001 1001 0x0022FF17

0101 1010 0x0022FF18

1111 0101 0x0022FF19

1011 0011 0x0022FF1A


 Cada objeto (variáveis, strings, vetores, etc.) que
reside na memória do computador ocupa um certo
número de bytes:

◦ Inteiros: 4 bytes consecutivos
◦ Caracteres: 1 byte
◦ Ponto-flutuante: 4 bytes consecutivos

 Cada objeto tem um endereço.


Variável Valor Endereço
0001 1001
0x0022FF24
char string1[4] 0101 1010
1111 0101
1011 0011
0000 0001 0x0022FF14
0001 1001
0101 1010
1111 0101
1011 0011
0000 0001
0001 1001
float real[4] 0101 1010
1111 0101
1011 0011
0000 0001
0001 1001
0101 1010
1111 0101
1011 0011
0000 0001
0001 1001 0x0022FF10
char string[4] 0101 1010
1111 0101
1011 0011


int x = 100;

 Ao declararmos uma variável x como acima, temos
associados a ela os seguintes elementos:

◦ Um nome (x)
◦ Um endereço de memória ou referência (0xbfd267c4)
◦ Um valor (100)

 Para acessarmos o endereço de uma variável,
utilizamos o operador &


 Um ponteiro (apontador ou pointer) é um
tipo especial de variável cujo valor é um
endereço.

 Um ponteiro pode ter o valor especial NULL,
quando não contém nenhum endereço.

 NULL é uma constante definida na
biblioteca stdlib.h.


*var

 A expressão acima representa o conteúdo do
endereço de memória guardado na variável
var

 Ou seja, var não guarda um valor, mas sim
um endereço de memória.


int x;
int *ap; // apontador para inteiros
ap = &x; // ap aponta para x

0000 0000 (00) 0x0022FF14

ap 0010 0010 (22)
1111 1111 (FF)
0001 0000 (10)
0000 0001 0x0022FF10

x 0001 1001
0101 1010
1111 0101

 Há vários tipos de ponteiros:
◦ ponteiros para caracteres
◦ ponteiros para inteiros
◦ ponteiros para ponteiros para inteiros
◦ ponteiros para vetores
◦ ponteiros para estruturas

 O compilador C faz questão de saber de que tipo
de ponteiro você está definindo.


int *ap_int; // apontador para int
char *ap_char; // apontador para char
float *ap_float; // apontador para float
double *ap_double; // apontador para double

// apontador para apontador
int **ap_ap_int;


 Um conjunto limitado de operação
aritméticas pode ser executado.

 Os ponteiros são endereços de memória.
Assim, ao somar 1 a um ponteiro, você estará
indo para o próximo endereço de memória do
tipo de dado especificado.


int *ap;

00 00 00
22 22 22
FF FF FF
18 14 10

ap ap+1 ap+2


 Sempre que somar ou subtrair ponteiros,
deve-se trabalhar com o tamanho do tipo de
dado utilizado.

 Para isso você pode usar o operador
sizeof().


 O while deve ser usado sempre que:
◦ Não soubermos exatamente quantas vezes o laço
deve ser repetido
◦ O teste deva ser feito antes de iniciar a execução de
um bloco de comandos
◦ Houver casos em que o laço não deva ser repetido
nenhuma vez antes do teste da condição

 Atenção:
◦ As variáveis usadas no teste devem ser inicializadas
antes do teste.


 Permite que um certo trecho de programa
seja executado ATÉ QUE uma certa condição
deixe de ser verdadeira:

do
{
<comandos_a_repetir>
} while (<condição>);

<comandos_após_laço_do-while>


 Funcionamento:
1.Executar os comando dentro do bloco do-while.
2.Testar a condição.
3.Se a condição for falsa, então sair do laço.
4.Se a condição for verdadeira, então retornar para
o passo 1.


 O comando do-while deve ser usado sempre
que:
◦ Não soubermos exatamente quantas vezes o laço
deve ser repetido

◦ O teste deva ser feito depois da execução de um
bloco de comandos

◦ O bloco de comandos deve se executado pelo
menos uma vez


 Ler um número e verificar se este é ou não
um número primo.

 Dada uma dívida de 10 mil reais que cresce a
juros de 2,5% ao mês e uma aplicação de
1.500 reais com rendimento de 4% ao mês,
escrever um algoritmo que determine o
numero de meses necessários para pagar a
dívida.


 Permite que um certo trecho de programa
seja executado um número determinado de
vezes.

for (comandos_inic; condição_teste;
incre/decremento)
{
<comandos_a_repetir>
}

<comandos_após_laço_for>;


 Funcionamento:
1.Executar os comandos de inicialização.
2.Testar a condição.
3.Se a condição for falsa então sair do laço for.
4.Se a condição for verdadeira então executar os
comandos que estão subordinados ao for.
5.Executar os comandos de incremento/decremento.
6.Voltar ao passo 2.


 Observações:

◦ Os comandos de inicialização são executados
apenas uma vez.

◦ O contador é incrementado/decrementado sempre
ao final da execução do bloco.

◦ O teste é feito sempre antes do início da execução
do bloco de comandos.


 O comando for deve ser usado sempre que:

◦ Soubermos exatamente quantas vezes o laço deve
ser repetido.

◦ O teste deva ser feito antes da execução de um
bloco de comandos.

◦ Houver casos em que o laço não deva ser repetido
nenhuma vez.


 Comandos for aninhados
◦ Um comando for pode ser utilizado dentro de
outro comando for.
◦ Cuidados devem ser tomados para não aumentar o
tempo de execução do algoritmo.


 Desenvolver 3 programas, cada programa
deverá imprimir uma das figuras abaixo
********** ***** **********
********* **** **** ****
******** *** *** ***
******* ** ** **
****** * * *
***** * * *
**** ** ** **
*** *** *** ***
** **** **** ****
* ***** **********


Estrutura de Dados - Ponteiros

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (20)

Ähnlich wie Estrutura de Dados - Ponteiros

Ähnlich wie Estrutura de Dados - Ponteiros (20)

Mehr von Adriano Teixeira de Souza

Mehr von Adriano Teixeira de Souza (19)

Estrutura de Dados - Ponteiros