Projeto de Algoritmos  |  Linguagem C  |  Índice  |  English

Endereços e ponteiros

Os conceitos de endereço e ponteiro são fundamentais em qualquer linguagem de programação. Em C, esses conceitos são explícitos; em algumas outras linguagens eles são ocultos (e representados pelo conceito mais abstrato de referência).  Dominar o conceito de ponteiro exige algum esforço e uma boa dose de prática.

Endereços

A memória RAM (= random access memory) de qualquer computador é uma sequência de bytes.  A posição (0, 1, 2, 3, etc.) que um byte ocupa na sequência é o endereço (= address) do byte.  (É como o endereço de uma casa em uma longa rua que tem casas de um lado só.)  Se  e  é o endereço de um byte então  e + 1  é o endereço do byte seguinte.

Cada variável de um programa ocupa um certo número de bytes consecutivos na memória do computador. Uma variável do tipo char ocupa 1 byte.  Uma variável do tipo int ocupa 4 bytes e um double ocupa 8 bytes em muitos computadores.  O número exato de bytes de uma variável é dado pelo operador sizeof. A expressão sizeof (char), por exemplo, vale 1 em todos os computadores e a expressão sizeof (int) vale 4 em muitos computadores.

Cada variável (em particular, cada registro e cada vetor) na memória tem um endereço. Na maioria dos computadores, o endereço de uma variável é o endereço do seu primeiro byte. Por exemplo, depois das declarações

char c;
int i;
struct {
   int x, y;
} ponto;
int v[4];

as variáveis poderiam ter os seguintes endereços (o exemplo é fictício):

c        89421
i        89422
ponto    89426
v[0]     89434
v[1]     89438
v[2]     89442

O endereço de uma variável é dado pelo opera­dor  & .  Assim, se  i  é uma variável então  &i  é o seu endereço.  (Não confunda esse uso de & com o operador lógico and, representado por && em C.)  No exemplo acima,  &i  vale 89422  e  &v[3]  vale 89446.

Outro exemplo: o segundo argumento da função de biblioteca scanf é o endereço da variável que deve receber o valor lido do teclado:

int i;
scanf ("%d", &i);

Exercícios 1

Ponteiros

Um ponteiro (= apontador = pointer) é um tipo especial de variável que armazena um endereço.  Um ponteiro pode ter o valor

NULL

que é um endereço inválido.  A macro NULL está definida na interface stdlib.h e seu valor é 0 (zero) na maioria dos computadores.

Se um ponteiro p armazena o endereço de uma variável i, podemos dizer  p aponta para i  ou  p é o endereço de i.  (Em termos um pouco mais abstratos, diz-se que p é uma referência à variável i.)  Se um ponteiro p tem valor diferente de NULL então

*p

é o valor da variável apontada por p.  (Não confunda esse operador * com o operador de multiplicação!)  Por exemplo, se i é uma variável e p vale &i então dizer *p é o mesmo que dizer i.

A seguinte figura dá um exemplo. Do lado esquerdo, um ponteiro p, armazenado no endereço 60001, contém o endereço de um inteiro.  O lado direito dá uma representação esquemática da situação:

Tipos de ponteiros.  Há vários tipos de ponteiros: ponteiros para bytes, ponteiros para inteiros, ponteiros para ponteiros para inteiros, ponteiros para registros, etc.  O computador precisa saber de que tipo de ponteiro você está falando. Para declarar um ponteiro p para um inteiro, escreva

int *p;

(Há quem prefira escrever int* p.) Para declarar um ponteiro p para um registro reg, diga

struct reg *p;

Um ponteiro r para um ponteiro que apontará um inteiro (como no caso de uma matriz de inteiros) é declarado assim:

int **r;

Exemplos.  Suponha que a, b e c são variáveis inteiras e veja um jeito bobo de fazer  c = a+b:

int *p; // p é um ponteiro para um inteiro
int *q; 
p = &a; // o valor de p é o endereço de a
q = &b; // q aponta para b
c = *p + *q;

Outro exemplo bobo:

int *p;  
int **r; // ponteiro para ponteiro para inteiro
p = &a;  // p aponta para a
r = &p;  // r aponta para p e *r aponta para a
c = **r + b;

Exercícios 2

Aplicação

Suponha que precisamos de uma função que troque os valores de duas variáveis inteiras, digamos i e j.  É claro que a função

void troca (int i, int j) { 
   int temp;
   temp = i; i = j; j = temp;
}

não produz o efeito desejado, pois recebe apenas os valores das variáveis e não as variáveis propriamente ditas.  A função recebe cópias das variáveis e troca os valores dessas cópias, enquanto as variáveis originais permanecem inalteradas.  Para obter o efeito desejado, é preciso passar à função os endereços das variáveis:

void troca (int *p, int *q)
{
   int temp;
   temp = *p; *p = *q; *q = temp;
}

Para aplicar essa função às variáveis i e j basta dizer  troca (&i, &j)  ou então

int *p, *q;
p = &i; q = &j;
troca (p, q);

Exercícios 3

Aritmética de endereços

Os elementos de qualquer vetor são armazenados em bytes consecutivos da memória do computador.  Se cada elemento do vetor ocupa s bytes, a diferença entre os endereços de dois elementos consecutivos é s.  Mas o compilador ajusta os detalhes internos de modo a criar a ilusão de que a diferença entre os endereços de dois elementos consecutivos é 1, qualquer que seja o valor de s.  Por exemplo, depois da declaração

int *v;
v = malloc (100 * sizeof (int));

o endereço do primeiro elemento do vetor é v, o endereço do segundo elemento é v+1, o endereço do terceiro elemento é v+2, etc.  Se i é uma variável do tipo int então

v + i

é o endereço do (i+1)-ésimo elemento do vetor.  As expressões  v + i  e  &v[i]  têm exatamente o mesmo valor e portanto as atribuições

*(v+i) = 789;
v[i] = 789;

têm o mesmo efeito.  Portanto, qualquer dos dois fragmentos de código abaixo pode ser usado para preencher o vetor v:

for (i = 0; i < 100; ++i)  scanf ("%d", &v[i]);
for (i = 0; i < 100; ++i)  scanf ("%d", v + i);

Todas essas considerações também valem se o vetor for alocado estaticamente (ou seja, antes que o programa comece a ser executado) por uma declaração como

int v[100];

mas nesse caso, v é uma espécie de ponteiro constante, cujo valor não pode ser alterado.

Exercícios 4