Referências vs ponteiros em C++: quando usar cada um

Duas formas de se referir a algo

Você já conhece os ponteiros: variáveis que armazenam um endereço e permitem alcançar o objeto que vive ali. As referências são a outra ferramenta que o C++ oferece para trabalhar indiretamente com um objeto existente. Elas se sobrepõem o suficiente para que iniciantes muitas vezes não saibam qual escolher, então esta página as coloca lado a lado.

A versão curta: uma referência é um alias. Depois que int& r = x; é executado, r é x: o mesmo objeto, com outro nome. Um ponteiro é um objeto separado que por acaso guarda o endereço de outro. Essa única diferença determina todo o resto.

Uma referência é um alias

Uma referência precisa ser vinculada a um objeto no momento em que é criada e, a partir daí, todo uso da referência toca o original.

#include <iostream>
using namespace std;

int main() {
    int score = 10;
    int& alias = score;   // alias e score agora são o mesmo objeto

    alias = 42;           // escreve diretamente em score
    cout << score << endl; // 42

    score = 7;
    cout << alias << endl; // 7 - eles se movem juntos
    return 0;
}

Repare que não há nenhum * para desreferenciar nem nenhum & para "pegar o endereço" no ponto de uso: você lê e escreve alias exatamente como um int comum. O & em int& alias faz parte do tipo, não é o operador de endereço.

Onde elas diferem

Os comportamentos abaixo são a própria razão de ambas as ferramentas existirem. Esta é a tabela para memorizar.

//                      reference            pointer
// must be initialized? yes                  no (but should be)
// can be null?         no                   yes (nullptr)
// can be reseated?     no                   yes
// pointer arithmetic?  no                   yes
// syntax to use it     just the name        *p  or  p->member
// taking address       &ref == &original    &p is the pointer's own address

Duas delas são as que mais confundem. Primeiro, uma referência nunca pode ser reassociada: atribuir algo a ela copia um valor para dentro do objeto referido, não aponta a referência para algo novo.

#include <iostream>
using namespace std;

int main() {
    int a = 1, b = 2;
    int& r = a;

    r = b;   // NÃO faz r se referir a b - copia o valor de b PARA DENTRO de a
    cout << a << endl; // 2  (a foi alterado)
    cout << b << endl; // 2

    b = 99;
    cout << r << endl; // 2  (r continua sendo alias de a, não de b)
    return 0;
}

Um ponteiro, em contrapartida, é livre para apontar para outro lugar a qualquer momento:

#include <iostream>
using namespace std;

int main() {
    int a = 1, b = 2;
    int* p = &a;

    p = &b;   // reassocia: p agora aponta para b
    *p = 99;  // escreve em b
    cout << a << endl; // 1
    cout << b << endl; // 99
    return 0;
}

Segundo, uma referência nunca pode ser legalmente nula, enquanto um ponteiro pode. Isso faz com que "nenhum valor" seja representável com um ponteiro, mas não com uma referência, uma propriedade na qual você vai se apoiar constantemente.

Escolhendo nos parâmetros de função

É aqui que a escolha mais aparece. Quando uma função precisa ler ou modificar o objeto de quem a chama, ambas funcionam, mas sinalizam intenções diferentes.

#include <iostream>
using namespace std;

// referência: o argumento SEMPRE existe; chamada mais limpa
void addTax(double& price) {
    price *= 1.2;
}

// ponteiro: o argumento é OPCIONAL; nullptr significa "pular"
void applyDiscount(double* price) {
    if (price == nullptr) return;   // quem chama pode optar por não participar
    *price *= 0.9;
}

int main() {
    double cart = 100.0;

    addTax(cart);              // sem &, lê-se como uma chamada normal
    cout << cart << endl;      // 120

    applyDiscount(&cart);      // o & explícito sinaliza "isto pode ser modificado"
    cout << cart << endl;      // 108

    applyDiscount(nullptr);    // legal: nada acontece
    return 0;
}

A versão com referência (addTax(cart)) é impossível de chamar com "nada", então dentro da função você nunca verifica se é nula: o objeto está garantido. A versão com ponteiro (applyDiscount(&cart)) anuncia no ponto de chamada, por meio do &, que o argumento pode mudar, e permite a quem chama passar nullptr para significar "não se aplica". Escolha aquela cuja garantia combine com a sua função.

Para parâmetros somente leitura de tipos grandes, a escolha idiomática é const T&: evita uma cópia e promete não modificar. Veja parâmetros de função para mais sobre passagem por valor versus passagem por referência.

Uma regra prática simples

Quando estiver em dúvida, prefira por padrão uma referência e só passe para um ponteiro quando precisar de uma capacidade que a referência não tem:

• Use uma referência quando o objeto sempre existir e sua identidade nunca mudar: o caso comum de parâmetros de função e aliases.
• Use um ponteiro quando qualquer uma destas condições for verdadeira:
  • "Nada" é um estado válido (argumento opcional, uma busca que pode não encontrar correspondência): um ponteiro pode ser nullptr.
  • Você precisa apontar para objetos diferentes ao longo do tempo: um ponteiro pode ser reassociado.
  • Você está gerenciando memória da heap que vai liberar com delete, ou percorrendo um array com aritmética de ponteiros.

Se nada disso se aplicar, uma referência é a escolha mais limpa e segura, porque o compilador garante por você "sempre válida, nunca reassociada".

Erros comuns a evitar

• Esperar que ref = other reassocie. Em vez disso, ele atribui um valor para dentro do objeto referido. Referências ficam vinculadas para a vida toda; se precisar reassociar, use um ponteiro.
• Retornar uma referência (ou ponteiro) para uma variável local. int& f() { int x = 5; return x; } retorna uma referência pendente: x morre quando f retorna e usar o resultado é comportamento indefinido. A mesma armadilha atinge os ponteiros (return &x;).
• Forjar uma "referência nula". Escrever int& r = *p; quando p é nullptr é comportamento indefinido no instante em que você desreferencia, não uma referência "vazia" segura. Expresse a opcionalidade com um ponteiro ou std::optional.
• Recorrer a um ponteiro por hábito. Se o argumento sempre existe e você nunca vai reassociá-lo, uma referência elimina toda uma categoria de verificações de nulo e de falhas. Não pague por capacidades que você não usa.

Próximo: Memória dinâmica

Até agora cada objeto que você referenciou ou apontou era criado automaticamente na pilha. A próxima página, memória dinâmica, cobre new e delete: pedir memória ao sistema operacional em tempo de execução, por que são os ponteiros (não as referências) que a possuem, e como esquecer de liberá-la causa vazamentos.