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?
- Como o mesmo conceito aparece em cada linguagem?
- Aí você pergunta: o que ponteiro tem a ver com desempenho?
- 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. E ela não pertence a uma linguagem só: o C e o Go têm ponteiros com esse nome, e o Python e o PHP usam o mesmo princípio de chegar até um dado sem fazer outra cópia dele. Este artigo começa pelo C, onde o endereço aparece sem disfarce, passa pelas outras três linguagens e termina com o que ponteiro tem a ver com desempenho.
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!
Como o mesmo conceito aparece em cada linguagem?
O nome muda, os símbolos mudam, e a ideia continua a mesma: guardar o caminho até um dado, em vez de guardar outra cópia dele. Veja as quatro linguagens deste artigo lado a lado:
| Linguagem | Como a ideia aparece | O que os exemplos mostraram |
|---|---|---|
| C | Ponteiro, com & e *, e com contas de endereço | *(ponteiro + 1) leu o segundo valor do vetor |
| Go | Ponteiro, com & e *, sem contas de endereço | ponteiro + 1 nem compilou |
| Python | Dois nomes ligados ao mesmo objeto | b.append(4) mudou a lista a |
| PHP | Referência, com & no parâmetro | A função dobrar alterou a variável de quem chamou |
No Python, a regra está na documentação: a atribuição não copia o objeto, só liga um nome a ele. Foi por isso que b = a não criou uma segunda lista.
Aí você pergunta: o que ponteiro tem a ver com desempenho?
Tudo! Você viu na função de troca que uma função recebe cópias dos dados. Com um inteiro, a cópia custa quase nada. Com um dado grande, o computador precisa copiar byte por byte a cada chamada. Passar o endereço evita esse trabalho: o que viaja até a função é só o endereço.
O programa abaixo mede a diferença. Ele cria um pacote com 250 mil inteiros e chama duas funções, dez mil vezes cada uma: a primeira recebe uma cópia do pacote, e a segunda recebe o endereço dele. O pacote é uma struct, assunto do próximo artigo. Por enquanto, basta saber que ela junta vários dados em uma variável só.
#include <stdio.h>
#include <time.h>
struct Foto
{
int pontos[250000]; // um pacote com 250 mil inteiros
};
int ler_com_copia(struct Foto foto) // recebe uma cópia do pacote inteiro
{
return foto.pontos[0] + foto.pontos[249999];
}
int ler_com_endereco(struct Foto *foto) // recebe só o endereço do pacote
{
return (*foto).pontos[0] + (*foto).pontos[249999];
}
int main(void)
{
struct Foto foto = {0}; // começa com zero em todas as posições
foto.pontos[0] = 1;
foto.pontos[249999] = 2;
printf("tamanho do pacote: %zu bytes\n", sizeof(foto));
printf("tamanho do endereço: %zu bytes\n", sizeof(&foto));
int soma = 0;
clock_t inicio = clock();
for (int i = 0; i < 10000; i++) {
soma = soma + ler_com_copia(foto);
}
double com_copia = (double) (clock() - inicio) * 1000 / CLOCKS_PER_SEC;
inicio = clock();
for (int i = 0; i < 10000; i++) {
soma = soma + ler_com_endereco(&foto);
}
double com_endereco = (double) (clock() - inicio) * 1000 / CLOCKS_PER_SEC;
printf("soma das leituras: %d\n", soma);
printf("dez mil chamadas com cópia: %.0f ms\n", com_copia);
printf("dez mil chamadas com endereço: %.0f ms\n", com_endereco);
return 0;
}
Saída (os tempos mudam a cada execução e de um computador para outro):
tamanho do pacote: 1000000 bytes tamanho do endereço: 8 bytes soma das leituras: 60000 dez mil chamadas com cópia: 444 ms dez mil chamadas com endereço: 0 ms
O pacote ocupa 1.000.000 de bytes, e o endereço dele, 8 bytes. Com a cópia, cada chamada carregou o milhão de bytes, e as dez mil chamadas levaram 444 milissegundos. Com o endereço, levaram menos de 1 milissegundo. O teste foi compilado com o GCC sem opções de otimização.
No Go a regra é a mesma. A documentação da linguagem diz que tudo é passado por valor, que passar um ponteiro copia o ponteiro, e não o dado apontado, e que, quando o dado é grande, usar o ponteiro pode sair mais barato.
É por isso que o conceito volta em tantos assuntos:
- Nas funções: o endereço permite alterar o dado de quem chamou.
- Nas estruturas de dados: em C, é com ponteiros que se liga um elemento ao seguinte. É assim que se monta a lista encadeada, que vem a seguir nesta jornada.
- Na otimização: o endereço evita cópias que custam tempo e memória.
ATENÇÃO: evitar a cópia tem um preço. Quem recebe o endereço consegue alterar o dado original, de propósito ou por engano. Foi o que aconteceu com a lista a no exemplo em Python.
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 as respostas sobre por que o Go não tem aritmética de ponteiros, sobre a passagem de parâmetros por valor e sobre o uso de ponteiro com dados grandes.
- Python, documentação oficial. copy: Shallow and deep copy operations (em inglês), com a explicação de que a atribuição não copia objetos, só liga um nome a um objeto.
- Os exemplos deste artigo foram executados em Python 3.13, PHP 8.3, GCC 13 e Go 1.24.

Continue a conversa