C Ponteiro para Ponteiro

Um ponteiro é uma variável que guarda o endereço de outra variável. Mas o ponteiro também é uma variável: ele mora em algum lugar da memória e tem o seu próprio endereço. Então nada impede que outro ponteiro guarde esse endereço. Isso é um ponteiro para ponteiro, escrito com dois asteriscos: int **pp. Parece um trava-língua, mas resolve um problema bem concreto: deixar uma função mudar um ponteiro de quem a chamou. E é exatamente o tipo do famoso char **argv do main.

Esta aula supõe que você já leu Ponteiros e Passar por Ponteiro. Todos os programas foram compilados com o gcc 15.2 na máquina fictícia da Ana (usuária ana, computador notebook), na pasta ~/c, com o comando padrão do guia: gcc -std=c23 -Wall -Wextra arquivo.c -o programa.

A ideia: o bilhete que diz onde está o bilhete

Pense numa caça ao tesouro na festa da Ana. O tesouro (um saquinho com 10 moedas) está escondido na gaveta 44. Quem guarda o segredo é um bilhete que diz "o tesouro está na gaveta 44". Esse bilhete, por sua vez, foi escondido na gaveta 48.

A Ana entrega para a primeira criança um segundo bilhete: "procure o bilhete na gaveta 48". A criança abre a gaveta 48, lê o primeiro bilhete, vai até a gaveta 44 e acha as moedas. Dois saltos.

Cada asterisco é um salto. Com p você precisa de um salto até as moedas (*p). Com pp, de dois (**pp).

1. Declarar um ponteiro para ponteiro

O programa abaixo monta a caça ao tesouro e mostra onde cada coisa mora. O %p do printf mostra um endereço (veja Memória e Endereços); o (void *) antes de cada endereço é a forma que o %p pede, explicada em Ponteiro void*.

#include <stdio.h>

int main(void) {
    int moedas = 10;
    int *p = &moedas;
    int **pp = &p;

    printf("moedas = %d, mora em %p\n", moedas, (void *)&moedas);
    printf("p      = %p, mora em %p\n", (void *)p, (void *)&p);
    printf("pp     = %p, mora em %p\n", (void *)pp, (void *)&pp);
    printf("*pp    = %p\n", (void *)*pp);
    printf("**pp   = %d\n", **pp);
    return 0;
}

int moedas = 10;

Uma variável comum: o tesouro.

int *p = &moedas;

p é um ponteiro para int e guarda o endereço de moedas. É o primeiro bilhete.

int **pp

Leia de trás para a frente: pp é um ponteiro (*) para um ponteiro (*) para int. O tipo dele é int **.

= &p;

pp guarda o endereço de p (não o de moedas). É o segundo bilhete.

*pp

Um salto: "o que está guardado no lugar para onde pp aponta". Lá está p, então *pp é p: o endereço de moedas.

**pp

Dois saltos: *(*pp), ou seja, *p, ou seja, moedas: o número 10.

$ gcc -std=c23 -Wall -Wextra pp.c -o pp
$ ./pp
moedas = 10, mora em 0x7ffc78692c44
p      = 0x7ffc78692c44, mora em 0x7ffc78692c48
pp     = 0x7ffc78692c48, mora em 0x7ffc78692c50
*pp    = 0x7ffc78692c44
**pp   = 10

Siga os números: o valor de p (…c44) é o endereço de moedas; o valor de pp (…c48) é o endereço de p. Os endereços mudam a cada execução (o Linux sorteia onde a memória começa), mas essa amarração é sempre a mesma.

A mesma coisa em forma de tabela, do jeito que a memória é de verdade (uma rua de casas numeradas):

As três perguntas

Uma regra prática para nunca se perder: cada * que você escreve na frente do nome tira um * do tipo. pp é int **; *pp é int *; **pp é int. E cada & põe um: moedas é int, &moedas é int *, &p é int **.

2. Mudar as coisas pelo ponteiro para ponteiro

Com pp na mão você pode mexer em dois lugares diferentes, dependendo de quantos asteriscos usa:

• **pp = 15; muda o valor final (o tesouro).
• *pp = &outra; muda o ponteiro do meio: agora ele aponta para outra variável.

No jogo da Ana, duas jogadoras disputam uma partida e o ponteiro vez indica de quem é a vez:

#include <stdio.h>

int main(void) {
    int ana = 10;
    int bia = 50;
    int *vez = &ana;
    int **pp = &vez;

    **pp = 15;
    printf("ana = %d, bia = %d, *vez = %d\n", ana, bia, *vez);

    *pp = &bia;
    printf("ana = %d, bia = %d, *vez = %d\n", ana, bia, *vez);

    **pp = 55;
    printf("ana = %d, bia = %d, *vez = %d\n", ana, bia, *vez);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra mudar.c -o mudar
$ ./mudar
ana = 15, bia = 50, *vez = 15      « **pp = 15 mudou a ana
ana = 15, bia = 50, *vez = 50      « *pp = &bia: agora vez aponta para a bia
ana = 15, bia = 55, *vez = 55      « o mesmo **pp = 55 agora muda a bia

#include <stdio.h>

int main(void) {
    int ana = 10;
    int bia = 50;
    int *vez = &ana;
    int **pp = &vez;

    **pp = 15;
    printf("ana = %d, bia = %d, *vez = %d\n", ana, bia, *vez);

    *pp = &bia;
    printf("ana = %d, bia = %d, *vez = %d\n", ana, bia, *vez);

    **pp = 55;
    printf("ana = %d, bia = %d, *vez = %d\n", ana, bia, *vez);
    return 0;
}

3. Para que serve: uma função que muda um ponteiro

Até aqui, pp só complicou o que vez fazia sozinho. O motivo de existir o ** aparece com funções. Lembre da regra de Passar por Ponteiro: em C, a função recebe uma cópia de cada argumento. Para uma função mudar um int de quem chamou, ela recebe um int *. Pela mesma lógica:

A versão que não funciona

A Ana quer uma função criar_placar que reserve memória para um placar e deixe o ponteiro do main apontando para ela. Para reservar memória, o programa usa malloc ("memory allocation", reservar memória), que devolve o endereço da memória nova; a aula malloc e free explica tudo com calma. Aqui só importa: malloc devolve um endereço, e alguém precisa guardá-lo.

#include <stdio.h>
#include <stdlib.h>

void criar_placar(int *placar) {
    placar = malloc(sizeof *placar);
    if (placar == NULL) return;
    *placar = 0;
    printf("Dentro da função: placar = %p\n", (void *)placar);
}

int main(void) {
    int *placar = NULL;
    criar_placar(placar);
    printf("De volta no main: placar = %p\n", (void *)placar);
    if (placar == NULL) {
        printf("O main continua sem placar!\n");
        return 1;
    }
    free(placar);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra aloca1.c -o aloca1
$ ./aloca1
Dentro da função: placar = 0x59ee8dd79010
De volta no main: placar = (nil)        « (nil) é como a glibc mostra o NULL
O main continua sem placar!

Compilou sem nenhum aviso, e mesmo assim não funcionou. O que aconteceu:

1. No main, placar vale NULL. A chamada criar_placar(placar) entrega uma cópia desse valor ao parâmetro, que também se chama placar mas é outra variável, que só existe dentro da função.
2. placar = malloc(…) guarda o endereço novo na cópia. O placar do main nem fica sabendo.
3. A função termina, a cópia desaparece, e o endereço da memória reservada se perde para sempre: além de não funcionar, o programa vazou memória (aula Vazamentos de Memória).

É o mesmo erro de escrever void dobrar(int n) { n = n * 2; } e esperar que o número de quem chamou dobre. O fato de a cópia ser um ponteiro não muda nada: mudar a cópia não muda o original. (Mudar o lugar para onde ela aponta, com *placar = …, funcionaria, mas aqui o que queremos mudar é o próprio ponteiro.)

A versão que funciona: int **

#include <stdio.h>
#include <stdlib.h>

void criar_placar(int **placar) {
    *placar = malloc(sizeof **placar);
    if (*placar == NULL) return;
    **placar = 0;
    printf("Dentro da função: *placar = %p\n", (void *)*placar);
}

int main(void) {
    int *placar = NULL;
    criar_placar(&placar);
    printf("De volta no main: placar = %p\n", (void *)placar);
    if (placar == NULL) {
        printf("O main continua sem placar!\n");
        return 1;
    }
    *placar += 3;
    printf("Placar: %d\n", *placar);
    free(placar);
    return 0;
}

void criar_placar(int **placar)

O parâmetro agora é o endereço do ponteiro do main. Ele ainda é uma cópia, mas uma cópia do endereço, e com o endereço dá para ir até o original.

*placar = malloc(…);

Um salto: guarda o endereço novo no ponteiro do main.

sizeof **placar

O tamanho de um int (o que fica no fim dos dois saltos). sizeof não segue ponteiro nenhum de verdade; ele só olha o tipo, então funciona mesmo antes de existir memória.

**placar = 0;

Dois saltos: zera o número dentro da memória nova.

criar_placar(&placar);

O main passa o endereço do seu ponteiro. É o & que dá à função o poder de mudá-lo.

$ gcc -std=c23 -Wall -Wextra aloca2.c -o aloca2
$ ./aloca2
Dentro da função: *placar = 0x5e1a462c4010
De volta no main: placar = 0x5e1a462c4010     « agora o main recebeu o endereço
Placar: 3

#include <stdio.h>
#include <stdlib.h>

void criar_placar(int *placar) {
    placar = malloc(sizeof *placar);
    if (placar == NULL) return;
    *placar = 0;
}

int main(void) {
    int *placar = NULL;
    criar_placar(placar);
    if (placar == NULL) {
        printf("O main continua sem placar!\n");
        return 1;
    }
    *placar += 3;
    printf("Placar: %d\n", *placar);
    free(placar);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

void criar_placar(int **placar) {
    *placar = malloc(sizeof **placar);
    if (*placar == NULL) return;
    **placar = 0;
}

int main(void) {
    int *placar = NULL;
    criar_placar(&placar);
    if (placar == NULL) {
        printf("O main continua sem placar!\n");
        return 1;
    }
    *placar += 3;
    printf("Placar: %d\n", *placar);
    free(placar);
    return 0;
}

A outra saída: devolver o ponteiro

Muitas vezes dá para fugir do ** fazendo a função devolver o endereço com return:

#include <stdio.h>
#include <stdlib.h>

int *criar_placar(void) {
    int *placar = malloc(sizeof *placar);
    if (placar != NULL) {
        *placar = 0;
    }
    return placar;      // devolve o endereço (ou NULL, se faltou memória)
}

int main(void) {
    int *placar = criar_placar();
    if (placar == NULL) {
        printf("Faltou memória!\n");
        return 1;
    }
    *placar += 3;
    printf("Placar: %d\n", *placar);
    free(placar);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra aloca3.c -o aloca3
$ ./aloca3
Placar: 3

É o que o próprio malloc faz. Então, qual usar?

4. Listas de strings: char ** e o argv

O outro lugar onde o ** aparece o tempo todo é em listas de textos. Uma string em C é acessada por um char *, o endereço da primeira letra (aula Ponteiros e Strings). Uma lista de strings é então um array de char *, e o nome de um array vira o endereço do primeiro item (aula Ponteiros e Arrays). O endereço de um char * é um char **.

#include <stdio.h>

void listar(const char **lista) {
    for (const char **p = lista; *p != NULL; p++) {
        printf("- %s (começa com %c)\n", *p, **p);
    }
}

int main(void) {
    const char *compras[] = {"arroz", "feijão", "café", NULL};
    listar(compras);
    return 0;
}

const char *compras[]

Um array de ponteiros para texto. Cada item guarda o endereço de uma string; as letras moram em outro lugar. O const diz que não vamos mudar as letras (aula const e Ponteiros).

NULL

Um último item "vazio" marca o fim da lista, assim quem percorre não precisa saber o tamanho. (O argv também termina com um NULL.)

listar(compras)

O array vira o endereço do primeiro item, &compras[0], que é um const char **.

const char **p = lista

p anda pelos itens da lista, um por vez (p++ pula um ponteiro inteiro, 8 bytes no laboratório).

*p

Um salto: o item atual, um const char *, que o %s mostra como texto.

**p

Dois saltos: a primeira letra do item atual, um char, mostrada pelo %c.

$ gcc -std=c23 -Wall -Wextra frutas.c -o frutas
$ ./frutas
- arroz (começa com a)
- feijão (começa com f)
- café (começa com c)

O argv do main

O main pode receber o que você digita depois do nome do programa no terminal. A forma completa dele é int main(int argc, char **argv), e agora você sabe ler esse tipo: argv aponta para o primeiro item de uma lista de strings, exatamente como o p acima. (Muita gente escreve char *argv[]; num parâmetro de função, as duas escritas são a mesma coisa.)

#include <stdio.h>

int main(int argc, char **argv) {
    for (int i = 0; i < argc; i++) {
        printf("argv[%d] = %s\n", i, argv[i]);
    }
    return 0;
}

$ gcc -std=c23 -Wall -Wextra args.c -o args
$ ./args Ana Bia
argv[0] = ./args            « o primeiro item é o nome do programa
argv[1] = Ana
argv[2] = Bia

O argc ("argument count") conta os itens; o argv ("argument vector", lista de argumentos) é a lista. Os detalhes estão em Argumentos da Linha de Comando.

Quando dá errado

$ gcc -std=c23 -Wall -Wextra erro1.c -o erro1
erro1.c: In function ‘main’:
erro1.c:13:18: error: passing argument 1 of ‘criar_placar’ from incompatible pointer type [-Wincompatible-pointer-types]
   13 |     criar_placar(placar);
      |                  ^~~~~~
      |                  |
      |                  int *
erro1.c:4:25: note: expected ‘int **’ but argument is of type ‘int *’
    4 | void criar_placar(int **placar) {
      |                   ~~~~~~^~~~~~

$ gcc -std=c23 -Wall -Wextra erro2.c -o erro2
erro2.c: In function ‘main’:
erro2.c:5:16: error: initialization of ‘int **’ from incompatible pointer type ‘int *’ [-Wincompatible-pointer-types]
    5 |     int **pp = &moedas;
      |                ^

$ gcc -std=c23 -Wall -Wextra erro3.c -o erro3
erro3.c: In function ‘main’:
erro3.c:7:14: warning: format ‘%d’ expects argument of type ‘int’, but argument 2 has type ‘int *’ [-Wformat=]
    7 |     printf("%d\n", *pp);
      |             ~^     ~~~
      |              |     |
      |              int   int *
      |             %ls
$ ./erro3
-34380812                « um pedaço do endereço, mostrado como número

#include <stdio.h>

int main(void) {
    int *p = NULL;
    int **pp = &p;
    printf("Vou escrever em **pp...\n");
    **pp = 5;
    printf("Escrevi!\n");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra nulo.c -o nulo
$ ./nulo
Vou escrever em **pp...
Falha de segmentação     (imagem do núcleo gravada) ./nulo

Referência rápida

Exercícios

Missão final: trocar os ponteiros, não os valores

primeiro aponta para 50
segundo aponta para 100
ouro = 100, prata = 50

#include <stdio.h>

void trocar(int **a, int **b) {
    // troque para onde *a e *b apontam
}

int main(void) {
    int ouro = 100;
    int prata = 50;
    int *primeiro = &ouro;
    int *segundo = &prata;

    trocar(&primeiro, &segundo);

    printf("primeiro aponta para %d\n", *primeiro);
    printf("segundo aponta para %d\n", *segundo);
    printf("ouro = %d, prata = %d\n", ouro, prata);
    return 0;
}

#include <stdio.h>

void trocar(int **a, int **b) {
    int *temp = *a;
    *a = *b;
    *b = temp;
}

int main(void) {
    int ouro = 100;
    int prata = 50;
    int *primeiro = &ouro;
    int *segundo = &prata;

    trocar(&primeiro, &segundo);

    printf("primeiro aponta para %d\n", *primeiro);
    printf("segundo aponta para %d\n", *segundo);
    printf("ouro = %d, prata = %d\n", ouro, prata);
    return 0;
}

Repare no tipo do temp: ele guarda um *a, que é um int *. Se você escrever int temp = *a;, o gcc recusa com error: initialization of ‘int’ from ‘int *’ makes integer from pointer without a cast ("transforma ponteiro em inteiro sem conversão"). Trocar ponteiros em vez de valores é muito usado para ordenar coisas grandes: em vez de copiar fichas inteiras de um lado para o outro, você troca só as setas (veja Ordenação).

Resumo

• Um ponteiro também mora num endereço; quem guarda esse endereço é um ponteiro para ponteiro: int **pp = &p;.
• pp é o endereço de p; *pp é o próprio p; **pp é o valor final. Cada * na frente tira um * do tipo; cada & põe um.
• *pp = &outra; muda para onde o ponteiro do meio aponta; **pp = 7; muda o valor final.
• Para uma função mudar um ponteiro de quem chama (por exemplo, guardar nele a memória de um malloc), ela recebe tipo ** e é chamada com &ponteiro. Com um tipo * ela só mudaria a cópia.
• Quando dá, devolver o ponteiro com return é mais simples; o ** fica para quando o return está ocupado ou há vários ponteiros a mudar (como no strtol).
• Listas de strings são arrays de char *; quem anda nelas é um char **, como o argv do main.
• Erros típicos: esquecer o & (incompatible pointer type, erro desde o gcc 14), um * a menos no printf e **pp com *pp valendo NULL (falha de segmentação).