Ponteiros

O problema

Um placar guarda a pontuação de um jogador. Você cria uma função para somar 10 pontos, mas o placar original não muda.

void adicionar(int pontos) {
    pontos += 10;          // altera apenas a cópia local
}

int placar = 20;
adicionar(placar);         // placar continua 20

Se a função só recebe cópias, como ela pode alcançar a variável original e atualizá-la?

Pense em um endereço residencial. Você não entrega a casa a alguém: entrega o endereço, e a pessoa vai até lá.

Conceitos centrais

Toda variável ocupa um lugar na memória, e esse lugar tem um endereço. Um ponteiro é uma variável cujo valor é um endereço. Por meio dele, é possível ler e alterar o objeto que mora naquele endereço.

int *p

Declara p como ponteiro para int.

&x

Operador de endereço: o endereço da variável x.

*p

Desreferência (“seguir a seta”): o objeto que está no endereço guardado em p.

NULL

Valor especial que significa “não aponta para nada”.

int numero = 20;
int *p = №   // p guarda o endereço de numero
*p = 30;            // escreve 30 no endereço: numero agora vale 30
printf("%d %d\n", numero, *p);   // 30 30

Passagem por valor, mesmo com ponteiros

C sempre passa argumentos por valor. No exemplo do placar, que aparece completo logo abaixo, em “Na prática”, quando você passa &placar, a função recebe uma cópia do endereço. Como as duas cópias apontam para o mesmo lugar, escrever em *pontos altera o placar original. É isso que costumamos chamar de “passagem por referência” em C.

Na prática

#include <stdio.h>

void adicionar(int *pontos, int bonus) {
    *pontos += bonus;
}

int main(void) {
    int placar = 20;
    adicionar(&placar, 10);
    printf("%d\n", placar);
    return 0;
}

Saída: 30

Devolver mais de um resultado

Uma função em C retorna um único valor. Com ponteiros de saída, ela pode preencher quantos resultados forem necessários. scanf("%d", &x) usa esse mesmo padrão.

No exemplo abaixo, o vetor é recebido como const int v[]. O const avisa que a função só lê o vetor e não o altera. Ele é explicado com mais detalhes no fim da aula.

// Pré-condições: n >= 1; menor e maior apontam para variáveis válidas,
// diferentes entre si e fora do vetor v.
void min_max(const int v[], int n, int *menor, int *maior) {
    *menor = *maior = v[0];
    for (int i = 1; i < n; i++) {
        if (v[i] < *menor) *menor = v[i];
        if (v[i] > *maior) *maior = v[i];
    }
}

int w[] = {4, -2, 9, 0}, mn, mx;
min_max(w, 4, &mn, &mx);    // mn = -2, mx = 9

Ponteiro para struct

typedef struct { char nome[50]; float nota; } Aluno;
Aluno aluno = {"Ana", 8.5f};
Aluno *p = &aluno;
p->nota = 9.0f;      // equivale a (*p).nota = 9.0f

Use . com a variável e -> com o ponteiro. Os parênteses em (*p).nota são necessários, porque . tem precedência maior que *.

Ponteiro para ponteiro Aprofundamento

Um ponteiro também é uma variável, e por isso também tem endereço. Um ponteiro para ponteiro guarda esse endereço. Este programa é independente dos exemplos anteriores:

#include <stdio.h>

int main(void) {
    int x = 7, y = 9;
    int *p = &x;          // p aponta para x
    int **pp = &p;        // pp aponta para p

    **pp = 8;             // dois saltos: altera x
    *pp = &y;             // um salto: altera o próprio p, que passa a apontar para y

    printf("%d %d %d\n", x, *p, **pp);
    return 0;
}

Saída: 8 9 9

*pp é o próprio p; **pp é o inteiro para onde p aponta. Use isso quando uma função precisa alterar o ponteiro do chamador, por exemplo para fazê-lo apontar para outro lugar.

Ponteiros e vetores

Os elementos de um vetor ficam lado a lado na memória, sem espaços entre eles. Em quase todas as expressões, o nome do vetor é convertido em um ponteiro para o primeiro elemento. Por isso, int *p = v; é o mesmo que int *p = &v[0];, e uma função que recebe int v[] na verdade recebe int *v.

Compile e execute este programa:

#include <stdio.h>

int main(void) {
    int v[] = {10, 20, 30, 40, 50};
    int *p = v;                          // o mesmo que &v[0]

    printf("*p       = %d\n", *p);       // primeiro elemento
    printf("*(p + 2) = %d\n", *(p + 2)); // avança 2 elementos
    printf("p[2]     = %d\n", p[2]);     // mesma coisa, outra notação
    printf("&v[3] - &v[0] = %td elementos\n", &v[3] - &v[0]);
    printf("p + 1 fica %td bytes depois de p\n",
           (char *)(p + 1) - (char *)p);
    return 0;
}

A última linha usa um truque, converter para (char *), só para medir a distância em bytes. É uma curiosidade, e não algo que você precise usar no dia a dia. A figura mostra o que acontece na memória. Os endereços são ilustrativos: os reais mudam a cada execução, mas a distância de 4 bytes entre vizinhos é sempre a mesma em plataformas com int de 4 bytes.

Percorrendo um vetor com ponteiro

Em vez de um índice i que vai de 0 a n − 1, o laço pode usar um ponteiro que anda de v até v + n. A cada p++, ele avança para o próximo elemento:

int soma(const int *v, int n) {
    int total = 0;
    for (const int *p = v; p < v + n; p++) {  // para ao chegar em "fim"
        total += *p;                           // lê o elemento apontado
    }
    return total;
}

Exemplo real: leituras de um sensor

Uma estação meteorológica registra a temperatura de hora em hora. O programa precisa da média e do pico do dia, além de saber em qual leitura o pico aconteceu. A função maior devolve o endereço da maior leitura, e não o valor. Com o endereço, temos as duas coisas: *pico dá o valor, e pico - temp dá a posição.

#include <stdio.h>

// Soma as n leituras percorrendo o vetor com um ponteiro.
int soma(const int *v, int n) {
    int total = 0;
    for (const int *p = v; p < v + n; p++) {
        total += *p;
    }
    return total;
}

// Devolve o ENDEREÇO da maior leitura. Pré-condição: n >= 1.
const int *maior(const int *v, int n) {
    const int *pico = v;
    for (const int *p = v + 1; p < v + n; p++) {
        if (*p > *pico) {
            pico = p;
        }
    }
    return pico;
}

int main(void) {
    int temp[] = {21, 23, 27, 25, 22};          // leituras de hora em hora
    int n = sizeof temp / sizeof temp[0];       // 5: aqui sizeof enxerga o vetor

    const int *pico = maior(temp, n);
    printf("Leituras: %d\n", n);
    printf("Media: %.1f graus\n", soma(temp, n) / (float)n);
    printf("Pico: %d graus, na leitura %td\n", *pico, pico - temp);
    return 0;
}

Cálculo de n

A expressão sizeof temp / sizeof temp[0] divide o tamanho do vetor inteiro pelo tamanho de um elemento. Em main, temp ainda é um vetor. Em uma plataforma com int de 4 bytes, sizeof temp vale 20 e sizeof temp[0] vale 4. Em qualquer plataforma, a divisão dá n = 5. Dentro de soma, isso não funcionaria, como mostra a primeira armadilha abaixo.

pico - temp

A diferença entre dois ponteiros do mesmo vetor conta elementos. O pico está em temp + 2, então a diferença é 2. O especificador %td imprime esse tipo de valor (ptrdiff_t).

(float)n

Sem a conversão, 118 / 5 seria uma divisão inteira e daria 23, em vez de 23.6.

Exercícios progressivos

Cada exercício parte de uma situação de sistemas reais. Antes de abrir a dica, desenhe as variáveis como caixas e os ponteiros como setas, como na figura de ponteiros e vetores. A dica não entrega a resposta: ela indica a pergunta certa a fazer.

int passos = 4000;
int *contador = &passos;           // o relógio recebe o endereço

*contador = *contador + 500;       // relógio detectou 500 passos
passos = passos + 100;             // celular detectou 100 passos

printf("%d %d\n", passos, *contador);

void esvaziar(int itens, float total) {
    itens = 0;
    total = 0.0f;
}

int itens = 3;
float total = 89.90f;
esvaziar(itens, total);    // itens continua 3, total continua 89.90

void esvaziar(int *itens, float *total) {
    *itens = 0;          // escreve no endereço recebido
    *total = 0.0f;
}

int itens = 3;
float total = 89.90f;
esvaziar(&itens, &total);   // passa os ENDEREÇOS
printf("Itens: %d, total: %.2f\n", itens, total);

int sacar(float *saldo, float valor) {
    if (valor <= 0.0f || valor > *saldo) {
        return 0;               // recusado: saldo intacto
    }
    *saldo -= valor;            // só altera depois de validar
    return 1;
}

float saldo = 100.0f;
int ok = sacar(&saldo, 30.0f);
printf("%d %.2f\n", ok, saldo);     // 1 70.00
ok = sacar(&saldo, 100.0f);
printf("%d %.2f\n", ok, saldo);     // 0 70.00

void trocar(int *a, int *b) {
    int temp = *a;     // o "terceiro copo"
    *a = *b;
    *b = temp;
}

int fila[] = {101, 102, 103, 104};
trocar(&fila[0], &fila[2]);      // endereços dos dois elementos
for (int i = 0; i < 4; i++) printf("%d ", fila[i]);   // 103 102 101 104

int bpm[] = {72, 75, 90, 110, 95};
int *atual = bpm + 2;

// Devolve o endereço do maior valor do vetor. Pré-condição: n >= 1.
int *maior(int *v, int n) {
    int *m = v;
    for (int *p = v + 1; p < v + n; p++) {
        if (*p > *m) m = p;
    }
    return m;
}

// Calcula o dobro de x.
int *dobro_errado(int x) {
    int resultado = 2 * x;
    return &resultado;
}

int dobro(int x) {
    return 2 * x;      // devolve o VALOR, que é copiado para o chamador
}