Neste artigo
- O que é um endereço de memória?
- Como criar e usar um ponteiro?
- Para que serve um ponteiro? A troca dentro de uma função
- Aí você pergunta: e o vetor, tem a ver com ponteiro?
- O que é NULL?
- E em Go, que também tem ponteiro?
- E em Python e PHP, existe ponteiro?
- Quais são os erros mais comuns com ponteiros?
- Agora é com você!
Ponteiro é uma variável que guarda um endereço de memória, em vez de guardar um valor comum, como um número ou uma letra. Com o endereço em mãos, o programa consegue chegar até o dado que mora ali, para ler ou para alterar.
No artigo sobre funções, você viu que uma função recebe dados e devolve um resultado. No artigo sobre tuplas, trocou dois valores de lugar em Python com uma linha só. Agora tente fazer essa mesma troca em C, dentro de uma função. Não funciona! E o motivo é o assunto de hoje. Ponteiro tem fama de assunto difícil, mas a ideia cabe em uma frase: é um endereço anotado. Em C, as estruturas de dados que vêm a seguir nesta jornada, começando pela lista encadeada, são montadas com ele.
Pense no endereço de um amigo anotado em um papel. O papel não é a casa: é só o caminho até ela. Com o papel na mão, você consegue ir até lá e deixar uma encomenda. E dá para fazer várias cópias do papel sem construir casa nenhuma. O ponteiro é o papel, e a variável é a casa.

O que é um endereço de memória?
A memória do computador é uma longa fila de bytes, e cada byte tem um número: o seu endereço. Toda variável ocupa alguns desses bytes, e o endereço dela é o do primeiro byte que ocupa. É assim que o material de algoritmos do professor Paulo Feofiloff, do IME-USP, apresenta o assunto.
Em C, o operador & devolve o endereço de uma variável:
#include <stdio.h>
int main(void)
{
int idade = 30;
printf("valor: %d\n", idade);
printf("endereco: %p\n", (void *) &idade);
return 0;
}
Saída (o endereço muda a cada execução):
valor: 30 endereco: 0x7fffab98d014
O número que começa com 0x está em hexadecimal, a base 16. Não precisa decorar nem interpretar esse número: o que importa é que ele existe e identifica onde a variável mora.
Como criar e usar um ponteiro?
São dois símbolos novos, e os dois aparecem neste programa:
#include <stdio.h>
int main(void)
{
int idade = 30;
int *ponteiro = &idade; // guarda o endereço de idade
printf("%d\n", *ponteiro); // lê o valor que está no endereço
*ponteiro = 31; // altera o valor que está no endereço
printf("%d\n", idade);
return 0;
}
Saída:
30 31
| Símbolo | Onde aparece | O que significa |
|---|---|---|
& | &idade | O endereço da variável idade |
* na declaração | int *ponteiro | Esta variável é um ponteiro para um inteiro |
* no uso | *ponteiro | O valor que está no endereço guardado |

Quando o ponteiro guarda o endereço de idade, dizemos que ele aponta para idade. Repare na última parte do programa: a linha *ponteiro = 31 não menciona a variável idade, mas foi ela que mudou. Sacou? Quem tem o endereço consegue mexer no valor.
ATENÇÃO: o asterisco tem dois papéis. Na declaração, ele avisa que a variável é um ponteiro. No uso, ele manda buscar o valor que está no endereço. E nenhum dos dois é a multiplicação.
Para que serve um ponteiro? A troca dentro de uma função
Aqui está o problema do começo do artigo. As duas funções abaixo tentam trocar dois valores. Só uma consegue:
#include <stdio.h>
void trocar_errado(int a, int b)
{
int auxiliar = a;
a = b;
b = auxiliar;
}
void trocar(int *a, int *b)
{
int auxiliar = *a;
*a = *b;
*b = auxiliar;
}
int main(void)
{
int x = 5;
int y = 3;
trocar_errado(x, y);
printf("%d %d\n", x, y);
trocar(&x, &y);
printf("%d %d\n", x, y);
return 0;
}
Saída:
5 3 3 5

A primeira função recebe cópias dos valores. Ela troca as cópias, termina, e as variáveis originais continuam como estavam. A segunda recebe os endereços e, com eles, alcança as variáveis de verdade. Por isso a chamada muda: trocar(&x, &y), com o & na frente de cada uma. O material do IME-USP usa esse mesmo par de funções, a errada e a certa, para mostrar por que os ponteiros existem.
Aí você pergunta: e o vetor, tem a ver com ponteiro?
Tem tudo a ver! Os valores de um vetor ficam um ao lado do outro na memória. E o nome do vetor funciona como o endereço do primeiro valor:
#include <stdio.h>
int main(void)
{
int notas[3] = {7, 8, 9};
int *ponteiro = notas; // o mesmo que ¬as[0]
printf("%d\n", *ponteiro);
printf("%d\n", *(ponteiro + 1));
printf("%d\n", ponteiro[2]);
return 0;
}
Saída:
7 8 9
As três linhas leem o vetor por caminhos diferentes. A do meio soma 1 ao ponteiro, e o compilador entende que é para andar um valor inteiro para frente, e não um byte. Em C, v[i] e *(v + i) são duas formas de escrever a mesma coisa.
O que é NULL?
É o valor de um ponteiro que não aponta para lugar nenhum. Serve como aviso: “aqui ainda não tem endereço válido”. Antes de usar um ponteiro que pode estar vazio, o programa testa:
#include <stdio.h>
int main(void)
{
int *ponteiro = NULL; // ainda não aponta para nada
if (ponteiro == NULL) {
printf("ponteiro vazio\n");
}
int idade = 30;
ponteiro = &idade;
if (ponteiro != NULL) {
printf("%d\n", *ponteiro);
}
return 0;
}
Saída:
ponteiro vazio 30
Você verá esse teste o tempo todo nas estruturas de dados: é com NULL que uma lista encadeada marca o seu fim.
E em Go, que também tem ponteiro?
O Go tem ponteiros com os mesmos dois símbolos do C: o & devolve o endereço, e o * chega até o valor. O programa abaixo junta três exemplos deste artigo: ler e alterar pelo endereço, trocar dois valores dentro de uma função e testar o ponteiro vazio.
package main
import "fmt"
func trocar(a *int, b *int) {
auxiliar := *a
*a = *b
*b = auxiliar
}
func main() {
idade := 30
ponteiro := &idade // guarda o endereço de idade
fmt.Println(*ponteiro) // lê o valor que está no endereço
*ponteiro = 31 // altera o valor que está no endereço
fmt.Println(idade)
x, y := 5, 3
trocar(&x, &y)
fmt.Println(x, y)
var vazio *int // ainda não aponta para nada
fmt.Println(vazio == nil)
}
Saída:
30 31 3 5 true
A troca funciona pelo mesmo motivo: a função recebe os endereços. E o ponteiro que ainda não recebeu endereço vale nil, que faz o papel do NULL.
ATENÇÃO: o Go tirou duas armadilhas do caminho. A primeira é a conta com endereços. Tentei escrever ponteiro + 1, como no exemplo do vetor em C, e o programa nem compilou. A documentação do Go explica que a escolha foi feita por segurança. A segunda é o ponteiro vazio: quando tentei ler o valor de um ponteiro que valia nil, o programa parou na hora, com uma mensagem clara:
invalid operation: ponteiro + 1 (mismatched types *int and untyped int) panic: runtime error: invalid memory address or nil pointer dereference
A primeira linha é do compilador. A segunda apareceu na execução.
E em Python e PHP, existe ponteiro?
Não com esse nome, nem com asterisco. Mas a ideia de “dois caminhos para o mesmo dado” existe, e explica um comportamento que pega muita gente de surpresa. Veja em Python:
a = [1, 2, 3] b = a # b não é uma cópia: é outro nome para a mesma lista b.append(4) print(a)
Saída:
[1, 2, 3, 4]
O programa mexeu em b, e quem mudou foi a! As duas variáveis são nomes para a mesma lista. Em PHP, o & na frente de um parâmetro faz a função mexer na variável original:
<?php
function dobrar(int &$numero): void
{
$numero = $numero * 2;
}
$valor = 21;
dobrar($valor);
echo $valor, "\n";
Saída:
42
O manual do PHP faz questão de avisar que as referências da linguagem não são ponteiros como os do C: não guardam endereços de memória e não aceitam contas com endereços. O efeito para quem programa, porém, é parecido. Foque no conceito, e não na linguagem!
Quais são os erros mais comuns com ponteiros?
- Usar um ponteiro que não recebeu endereço. Um ponteiro recém-criado guarda um endereço qualquer. Uma boa prática é começar com
NULLe testar antes de usar. - Esquecer o & na chamada. Escrever
trocar(x, y)passa os valores, e não os endereços. O GCC compila, mas avisa:passing argument 1 of 'trocar' makes pointer from integer without a cast. Aviso de compilador merece ser lido! - Confundir os dois asteriscos.
int *pdeclara.*p = 10usa. - Esquecer que a função recebe cópias. Se a função precisa alterar uma variável de quem chamou, ela precisa receber o endereço.
Agora é com você!
Primeiro no papel. Desenhe as caixinhas da memória e acompanhe este trecho, linha por linha: int x = 10;, depois int *p = &x;, depois *p = *p + 5; e, por fim, int y = *p;. Quanto valem x e y no fim? Anote e só então confira no computador.
Depois, escreva uma função dobrar que recebe o endereço de um inteiro e dobra o valor que está lá. Chame a função no main e mostre o resultado. Tente sozinho, sem pedir a resposta pronta para ninguém, nem para a IA!
No próximo artigo desta série de base: struct, malloc e free. É com eles, mais os ponteiros, que se monta uma lista encadeada. Até lá!
Confiança Sempre!!!
Fontes:
- Instituto de Matemática e Estatística da USP, material do professor Paulo Feofiloff. Endereços e ponteiros, com a definição de endereço, os operadores, a função de troca e a relação entre vetores e ponteiros.
- PHP, manual oficial. What References Are Not, com o aviso de que referências não são ponteiros.
- ICMC-USP, notas de aula. SME0230, aula 9: ponteiros, com o ponteiro como variável que guarda um endereço, o operador & e os usos do asterisco.
- UFSC, Curso de Programação C em Ambientes Linux. Aula 4: ponteiros, com a declaração, o valor NULL e os operadores de endereço e de indireção.
- Unicamp, Instituto de Computação. MC102, aula 11: ponteiros, com os dois operadores de ponteiros e os cuidados no uso.
- Unicamp, Instituto de Computação. MC-102, aula 18: Ponteiros I, com a passagem de parâmetros por valor e a relação entre ponteiros e vetores.
- IME-USP. MAC0122, aula 5: endereços e ponteiros, com a expressão apontar para, a função de troca e os vetores vistos como endereços.
- UFSCar. AED1, aula 7: endereços, apontadores e estruturas, com os endereços das variáveis e das posições de um vetor.
- Go, documentação oficial. The Go Programming Language Specification (em inglês), com o tipo ponteiro e o valor nil do ponteiro que ainda não foi inicializado.
- Go, documentação oficial. Frequently Asked Questions (em inglês), com a resposta sobre por que o Go não tem aritmética de ponteiros.
- Os exemplos deste artigo foram executados em Python 3.13, PHP 8.3, GCC 13 e Go 1.24.

Continue a conversa