Algoritmos

Ponteiros em programação: o que são e para que servem

Capa do artigo Ponteiros em programação: o que são e para que servem
Leitura com foco

Entenda o contexto.
Leve para a prática.

Neste artigo
  1. O que é um endereço de memória?
  2. Como criar e usar um ponteiro?
  3. Para que serve um ponteiro? A troca dentro de uma função
  4. Aí você pergunta: e o vetor, tem a ver com ponteiro?
  5. O que é NULL?
  6. E em Go, que também tem ponteiro?
  7. E em Python e PHP, existe ponteiro?
  8. Como o mesmo conceito aparece em cada linguagem?
  9. Aí você pergunta: o que ponteiro tem a ver com desempenho?
  10. Quais são os erros mais comuns com ponteiros?
  11. 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.

História em quadrinhos em três quadros: uma pessoa com o endereço 1000 anotado em um papel vai até a casa de número 1000 para deixar uma encomenda, e duas pessoas com cópias do papel apontam para a mesma casa
O ponteiro é o papel com o endereço, 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ímboloOnde apareceO que significa
&&idadeO endereço da variável idade
* na declaraçãoint *ponteiroEsta variável é um ponteiro para um inteiro
* no uso*ponteiroO valor que está no endereço guardado
Os dois operadores usados com ponteiros em C.
Diagrama de um ponteiro que guarda o endereço 1000 e aponta para a variável idade, de valor 30
O ponteiro guarda o endereço, e o endereço leva até o valor.

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
Diagrama comparando a função que recebe cópias de x e y, e não troca, com a função que recebe os endereços, e troca
À esquerda, a função troca as cópias. À direita, alcança as variáveis pelo endereço.

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 &notas[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:

LinguagemComo a ideia apareceO que os exemplos mostraram
CPonteiro, com & e *, e com contas de endereço*(ponteiro + 1) leu o segundo valor do vetor
GoPonteiro, com & e *, sem contas de endereçoponteiro + 1 nem compilou
PythonDois nomes ligados ao mesmo objetob.append(4) mudou a lista a
PHPReferência, com & no parâmetroA função dobrar alterou a variável de quem chamou
Um conceito, quatro jeitos de escrever.

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 NULL e 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 *p declara. *p = 10 usa.
  • 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.
Sobre quem escreve

Walmir Silva

Olá! Sou Walmir, engenheiro de software com MBA em Engenharia de Software e o cérebro por trás do GrowthCode e autor do livro "Além do Código".

Se você acha que programação é apenas sobre escrever código, prepare-se para expandir seus horizontes. Aqui, nós vamos além do código e exploramos as interseções fascinantes entre tecnologia, negócios, artes e filosofia.

Você está em busca de crescimento na carreira? Quer se destacar em um mercado competitivo? Almeja uma vida mais rica em conhecimento e realização? Então você chegou ao lugar certo. No GrowthCode, oferecemos insights profundos, estratégias comprovadas e um toque de sabedoria filosófica para catalisar seu crescimento pessoal e profissional.

Ver todos os artigos →

Continue a conversa

Compartilhe sua perspectiva

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Encontre sua próxima resposta

O que você quer aprender?

Preferências de cookies

Os cookies opcionais começam desligados. Você pode mudar a escolha a qualquer momento por esta tela.

NecessáriosSempre ativos

Guardam a sua escolha de cookies e mantêm o site funcionando. Não são usados para publicidade.

Contam visitas e mostram como o site é usado: Google Analytics e Microsoft Clarity, carregados pelo Google Tag Manager. Como esse contêiner também carrega tags de publicidade, as estatísticas só são ativadas junto com Publicidade e marketing.

Exibem anúncios do Google AdSense e medem campanhas e e-mails: pixels da Meta e do TikTok e o Mautic.

Permite que o Google escolha anúncios com base nos seus interesses. Desligado, os anúncios aparecem sem personalização. Depende de Publicidade e marketing.

Também é possível bloquear cookies nas configurações do navegador. Detalhes na Política de privacidade.