Ponteiros
Ponteiro é uma variável que guarda um endereço de memória.
Para compreender o uso de ponteiros, precisamos entender três elementos:
- Valor.
- Endereço.
- Tipo apontado.
Variável comum e ponteiro
Quando escrevemos int x = 10, temos uma variável chamada x. Ela ocupa um espaço na memória, como representado a seguir:
Quando fazemos int *p = &x;, p é um ponteiro para int e guarda o endereço de x.
Então:
pé o endereço guardado.*pé o valor que existe naquele endereço guardado.
Diferença entre & e *
O & significa endereço de. Exemplo:
&x é o endereço de x.
Já o *, em declaração:
significa: p é um ponteiro para int.
Em expressão:
significa: acesse o valor apontado por p.
Exemplo:
#include <stdio.h>
int main(void) {
int x = 10;
int *p = &x;
printf("x = %d\n", x);
printf("&x = %p\n", (void *) &x);
printf("p = %p\n", (void *) &p);
printf("*p = %d\n", *p);
return 0;
}
Saída conceitual:
Alterando um valor por meio de um ponteiro
#include <stdio.h>
int main(void) {
int x = 10;
int *p = &x;
*p = 99;
printf("x = %d\n", x);
return 0;
}
Saída:
Isso ocorre porque *p = 99; não muda o ponteiro, mas o valor guardado no endereço apontado por ele. Visualmente:
Ponteiro também é variável
Um ponteiro também ocupa memória.
Aqui p primeiro aponta para x. Depois, p passa a apontar para y.
#include <stdio.h>
int main(void) {
int x = 10;
int y = 20;
int *p = &x;
printf("*p = %d\n", *p);
p = &y;
printf("*p = %d\n", *p);
return 0;
}
Saída:
Ponteiros como parâmetros de função
Em C, argumentos são passados por valor. Exemplo:
#include <stdio.h>
void mudar(int n) {
n = 99;
}
int main(void) {
int x = 10;
mudar(x);
printf("x = %d\n", x);
return 0;
}
Saída:
Isso ocorre porque a função mudar() recebeu uma cópia de x:
Alterar n não altera x.
Usando ponteiro para alterar a variável original
#include <stdio.h>
void mudar(int *p) {
*p = 99;
}
int main(void) {
int x = 10;
mudar(&x);
printf("x = %d\n", x);
return 0;
}
Saída:
Agora, passamos o endereço de x. A função mudar() recebeu int *p e executou *p = 99, ou seja, alterou o valor no endereço recebido.
Um ponteiro como parâmetro pode servir para:
- Alterar uma variável externa.
- Evitar uma cópia grande.
- Preencher resultados.
- Passar arrays.
- Passar structs grandes.
- Permitir um retorno indireto.
Exemplo clássico: swap
#include <stdio.h>
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
int main(void) {
int x = 10;
int y = 20;
swap(&x, &y);
printf("x = %d\n", x);
printf("y = %d\n", y);
return 0;
}
Ponteiro para retornar múltiplos resultados
Podemos retornar vários valores indiretamente usando ponteiros:
#include <stdio.h>
void dividir(int a, int b, int *quociente, int *resto) {
*quociente = a / b;
*resto = a % b;
}
int main(void) {
int q, r;
dividir(10, 3, &q, &r);
printf("quociente = %d\n", q);
printf("resto = %d\n", r);
return 0;
}
Ponteiro nulo: NULL
Um ponteiro pode não apontar para nenhum objeto.
Isso significa: p não aponta para um objeto válido.
Antes de usar um ponteiro recebido, é bom verificar:
Exemplo:
Nunca faça:
Isso tenta acessar o endereço zero e normalmente causa uma falha de segmentação (segmentation fault).
Ponteiros e arrays
Em C, arrays e ponteiros têm uma relação estreita.
v geralmente "decai" para um ponteiro para o primeiro elemento. Em muitos contextos, v equivale a &v[0]. Exemplo:
#include <stdio.h>
int main(void) {
int v[3] = {10, 20, 30};
printf("%p\n", (void *) v);
printf("%p\n", (void *) &v[0]);
return 0;
}
Os endereços serão iguais.
Aritmética de ponteiros
Se:
Então, *p é v[0], *(p + 1) é v[1] e *(p + 2) é v[2]. Exemplo:
#include <stdio.h>
int main(void) {
int v[3] = {10, 20, 30};
int *p = v;
printf("%d\n", *p);
printf("%d\n", *(p + 1));
printf("%d\n", *(p + 2));
return 0;
}
Saída:
É importante saber que (p + 1) significa "próximo int", pois o array é de inteiros. Se um int ocupar 4 bytes, p + 1 avançará 4 bytes.
v[i] é açúcar sintático
Em C:
é equivalente a:
Por isso, v[2] é equivalente a *(v + 2).
Array como parâmetro de função
Quando escrevemos:
Isso é praticamente o mesmo que:
Exemplo:
#include <stdio.h>
void imprimir(int *v, int tam) {
for (int i = 0; i < tam; i++) {
printf("%d\n", v[i]);
}
}
int main(void) {
int numeros[] = {10, 20, 30};
imprimir(numeros, 3);
return 0;
}
A função não recebe o array inteiro. Ela recebe um ponteiro para o primeiro elemento. Por isso, precisa receber também o tamanho.
Não precisamos passar &numeros[0], pois vimos que, nesse contexto, numeros equivale a &numeros[0].
Strings são arrays de char
Em C, uma string é um array de char terminado com '\0'.
Na memória:
Exemplo:
#include <stdio.h>
int main(void) {
char nome[] = "Lucas";
char *p = nome;
printf("%c\n", *p);
printf("%c\n", *(p + 1));
printf("%s\n", p);
return 0;
}
Saída:
char nome[] e char *nome
Essa diferença é importante!
Array modificável
Aqui, o compilador cria um array local com os caracteres. Podemos modificá-lo:
Resultado: Mucas.
Ponteiro para literal
Aqui, nome aponta para uma string literal, geralmente armazenada em uma região de somente leitura. Tentar modificá-la causa um comportamento indefinido.
Forma correta para literal:
Assim deixamos claro que não vamos modificar essa string.
const com ponteiros
Ponteiro para valor constante
ou:
Significa:
- Não posso alterar o valor apontado por
p. - Mas posso mudar
ppara apontar para outro lugar.
Exemplo:
Ponteiro constante
Significa:
- Não posso mudar
ppara apontar para outro lugar. - Posso alterar o valor apontado.
Ponteiro constante para valor constante
Significa:
- Não posso mudar
p. - Não posso mudar
*p.
Regras para ler declarações com const
Leia perto do *:
p aponta para const int. O valor é constante.
p é constante. O ponteiro não muda.
Ponteiros para structs
Suponha:
Podemos criar:
Para acessar campos:
Essa forma é pouco usada. C oferece o operador ->:
Exemplo:
#include <stdio.h>
typedef struct {
int id;
char nome[50];
} Pessoa;
int main(void) {
Pessoa p = {1, "Lucas"};
Pessoa *ptr = &p;
printf("ID: %d\n", ptr->id);
printf("Nome: %s\n", ptr->nome);
ptr->id = 99;
printf("Novo ID: %d\n", ptr->id);
return 0;
}
Passando struct para função
Se passarmos uma struct por valor, copiaremos toda a estrutura.
Para structs grandes, é melhor passar um ponteiro:
Usamos const porque a função só lê.
Exemplo:
#include <stdio.h>
typedef struct {
int id;
char nome[50];
} Pessoa;
void imprimir_pessoa(const Pessoa *p) {
if (p == NULL)
return;
printf("ID: %d\n", p->id);
printf("Nome: %s\n", p->nome);
}
void mudar_id(Pessoa *p, int novo_id) {
if (p == NULL)
return;
p->id = novo_id;
}
int main(void) {
Pessoa pessoa = {1, "Lucas"};
imprimir_pessoa(&pessoa);
mudar_id(&pessoa, 10);
imprimir_pessoa(&pessoa);
return 0;
}
Retornando ponteiros de função
Uma função pode retornar um ponteiro, mas precisamos saber para onde esse ponteiro aponta.
Errado: retornar endereço de variável local
x está na pilha da função. Quando a função termina, x deixa de existir. O ponteiro fica pendente; isso é chamado de dangling pointer.
Correto: retornar ponteiro para heap
#include <stdio.h>
#include <stdlib.h>
int *criar_numero(void) {
int *p = malloc(sizeof(int));
if (p == NULL)
return NULL;
*p = 10;
return p;
}
int main(void) {
int *n = criar_numero();
if (n == NULL)
return 1;
printf("%d\n", *n);
free(n);
return 0;
}
Aqui, a memória continua existindo depois que a função termina porque foi alocada no heap. Entretanto, quem chama a função precisa liberá-la com free(n).