C Passar por Ponteiro

Na aula Parâmetros você viu que uma função recebe cópias dos valores que você passa. Isso é ótimo para proteger as suas variáveis, mas às vezes você quer que a função mude uma variável sua: trocar dois valores, ler um número do teclado, devolver dois resultados de uma vez. Em C, o jeito é entregar à função o endereço da variável. Esta é a aula em que os ponteiros começam a ser úteis de verdade.

Os programas foram compilados na máquina da Ana, na pasta ~/c, com gcc -std=c23 -Wall -Wextra arquivo.c -o programa.

A ideia: a fotocópia e o endereço

A Ana precisa que o contador corrija um documento. Ela tem duas opções:

• Mandar uma fotocópia. O contador rabisca a cópia à vontade, mas o original da Ana continua igual. É assim que o C passa argumentos normalmente: por valor, uma cópia.
• Mandar o endereço de onde o original está guardado ("está na gaveta 1000 do meu arquivo"). Aí o contador vai até lá e corrige o original. É a passagem por ponteiro.

O C só tem a primeira forma. A segunda é um truque em cima dela: você manda uma cópia... do endereço. A cópia de um endereço continua levando à mesma gaveta.

1. O problema: a função recebe cópias

O exemplo clássico: uma função que troca dois valores. Escrita do jeito mais natural, ela não funciona:

#include <stdio.h>

void trocar(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    printf("Dentro de trocar: a = %d, b = %d\n", a, b);
}

int main(void) {
    int a = 3;
    int b = 7;

    trocar(a, b);
    printf("No main:          a = %d, b = %d\n", a, b);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra trocar-errado.c -o trocar-errado
$ ./trocar-errado
Dentro de trocar: a = 7, b = 3      « as cópias foram trocadas
No main:          a = 3, b = 7      « os originais, não

Os nomes a e b se repetem, mas são quatro variáveis diferentes: duas do main e duas da função trocar, que nasceram com cópias dos valores e morreram no } da função. Dá para ver que moram em gavetas diferentes:

#include <stdio.h>

void mostrar(int x) {
    printf("na função: x mora em %p\n", (void *) &x);
}

int main(void) {
    int x = 3;
    printf("no main:   x mora em %p\n", (void *) &x);
    mostrar(x);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra copias.c -o copias
$ ./copias
no main:   x mora em 0x7ffd5cc7f8d4
na função: x mora em 0x7ffd5cc7f8bc     « outra gaveta: é uma cópia

2. A solução: mandar o endereço

Agora a função recebe ponteiros, e quem chama entrega os endereços:

#include <stdio.h>

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

int main(void) {
    int a = 3;
    int b = 7;

    trocar(&a, &b);
    printf("a = %d, b = %d\n", a, b);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra trocar.c -o trocar
$ ./trocar
a = 7, b = 3        « agora os originais trocaram

São três mudanças, todas pequenas:

void trocar(int *a, int *b)

Os parâmetros agora são ponteiros para int: a função recebe dois endereços. (O a e o b daqui ainda são cópias, mas cópias de endereços.)

int temp = *a;

Dentro da função, todo acesso aos valores leva *: *a é "a variável para onde a aponta", ou seja, o a do main. O temp é um int comum, que guarda o valor 3 durante a troca.

*a = *b; *b = temp;

Escreve nas gavetas do main: na de a, o valor da de b; na de b, o que estava guardado no temp.

trocar(&a, &b);

Na chamada, &: o main entrega os endereços das suas variáveis.

Passo a passo, com as gavetas:

pontos = 20

#include <stdio.h>

void dobrar(int *n) {
    // dobre o valor da variável para onde n aponta
}

int main(void) {
    int pontos = 10;

    dobrar(&pontos);
    printf("pontos = %d\n", pontos);
    return 0;
}

#include <stdio.h>

void dobrar(int *n) {
    *n = *n * 2;
}

int main(void) {
    int pontos = 10;

    dobrar(&pontos);
    printf("pontos = %d\n", pontos);
    return 0;
}

3. Por isso o scanf precisa do &

Agora o mistério da aula Entrada com scanf está resolvido. O scanf é uma função como a trocar: para guardar o número digitado na sua variável, ela precisa do endereço. scanf("%d", &idade) quer dizer "leia um inteiro e guarde na gaveta de idade".

Sem o &, o scanf recebe o valor de idade (uma cópia, 0) e o trata como se fosse um endereço. O gcc avisa:

#include <stdio.h>

int main(void) {
    int idade = 0;

    printf("Quantos anos você tem? ");
    scanf("%d", idade);
    printf("Você tem %d anos\n", idade);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra scanf-sem.c -o scanf-sem
scanf-sem.c: In function ‘main’:
scanf-sem.c:7:13: warning: format ‘%d’ expects argument of type ‘int *’, but argument 2 has type ‘int’ [-Wformat=]
    7 |     scanf("%d", idade);
      |            ~^   ~~~~~
      |             |   |
      |             |   int
      |             int *
$ echo 29 | ./scanf-sem
Falha de segmentação     (imagem do núcleo gravada) echo 29 | ./scanf-sem

"O formato %d espera um argumento do tipo int * (endereço de int), mas o argumento 2 é do tipo int". É só um aviso, então o programa foi gerado. Rodando, o scanf tentou guardar o 29 no "endereço 0" (o valor de idade), que é o ponteiro nulo, e o programa morreu. (A pergunta sumiu da tela por causa do balde do printf, explicado em Ponteiro Nulo; o echo 29 | faz o papel da pessoa digitando.)

No editor do guia, o resultado é outro, e mais traiçoeiro: o Clang avisa (format specifies type 'int *' but the argument has type 'int'), o programa não morre e mostra Você tem 0 anos. O 29 foi parar numa gaveta qualquer e o programa seguiu em frente com o valor errado. É mais um exemplo de por que um aviso do -Wall deve ser tratado como erro.

4. Devolver mais de um resultado

Uma função só tem um return, que devolve um valor só. Quando a resposta tem duas partes, os ponteiros resolvem: a função recebe os endereços de onde guardar cada parte. A Ana quer dividir balas entre crianças e saber quanto cada uma ganha e quantas sobram:

#include <stdio.h>

void dividir(int total, int pessoas, int *cada, int *sobra) {
    *cada = total / pessoas;
    *sobra = total % pessoas;
}

int main(void) {
    int balas = 17;
    int cada = 0;
    int sobra = 0;

    dividir(balas, 5, &cada, &sobra);
    printf("%d balas para 5 crianças: %d para cada, sobram %d\n", balas, cada, sobra);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra dividir.c -o dividir
$ ./dividir
17 balas para 5 crianças: 3 para cada, sobram 2

Repare na mistura: total e pessoas são de entrada (a função só lê, então vão por valor, sem ponteiro); cada e sobra são de saída (a função escreve, então vão por ponteiro). Parâmetros de saída costumam ficar no fim da lista.

O padrão "deu certo?" + resultado

Uma combinação muito comum: o return diz se deu certo, e o resultado vai por ponteiro. É exatamente o que o próprio scanf faz (devolve quantos itens leu, e guarda os valores pelos ponteiros):

#include <stdio.h>

bool ler_idade(int *idade) {
    printf("Quantos anos você tem? ");
    if (scanf("%d", idade) != 1) {
        return false;
    }
    return *idade >= 0 && *idade <= 130;
}

int main(void) {
    int idade = 0;

    if (ler_idade(&idade)) {
        printf("Daqui a 10 anos você terá %d.\n", idade + 10);
    } else {
        printf("Idade inválida.\n");
    }
    return 0;
}

$ gcc -std=c23 -Wall -Wextra ler.c -o ler
$ ./ler
Quantos anos você tem? 29
Daqui a 10 anos você terá 39.
$ ./ler
Quantos anos você tem? abc
Idade inválida.
$ ./ler
Quantos anos você tem? 200
Idade inválida.

Detalhe importante: dentro de ler_idade, o scanf recebe idade sem &. Aqui, idade já é um ponteiro (o endereço que veio do main); colocar & daria o endereço do ponteiro, que não é o que o scanf quer. O bool, o true e o false não precisam de #include no C23 (veja Booleanos).

Por valor ou por ponteiro: qual usar

Prefira por valor sempre que a função só precisar ler um valor simples: é mais seguro (a função não consegue estragar nada) e mais fácil de entender. Use ponteiro quando a mudança for o objetivo. Com structs, o ponteiro também evita copiar muitos bytes.

Quando dá errado

$ ./trocar-errado
Dentro de trocar: a = 7, b = 3
No main:          a = 3, b = 7

#include <stdio.h>

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

int main(void) {
    int a = 3;
    int b = 7;

    trocar(&a, &b);
    printf("a = %d, b = %d\n", a, b);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra ponteiro-local.c -o ponteiro-local
$ ./ponteiro-local
a = 3, b = 7

$ gcc -std=c23 -Wall -Wextra semecomercial.c -o semecomercial
semecomercial.c: In function ‘main’:
semecomercial.c:13:12: error: passing argument 1 of ‘trocar’ makes pointer from integer without a cast [-Wint-conversion]
   13 |     trocar(a, b);
      |            ^
      |            |
      |            int
semecomercial.c:13:12: note: possible fix: take the address with ‘&’
   13 |     trocar(a, b);
      |            ^
      |            &
semecomercial.c:3:18: note: expected ‘int *’ but argument is of type ‘int’
    3 | void trocar(int *a, int *b) {
      |             ~~~~~^
semecomercial.c:13:15: error: passing argument 2 of ‘trocar’ makes pointer from integer without a cast [-Wint-conversion]
   13 |     trocar(a, b);
      |               ^
      |               |
      |               int
semecomercial.c:13:15: note: possible fix: take the address with ‘&’
   13 |     trocar(a, b);
      |               ^
      |               &
semecomercial.c:3:26: note: expected ‘int *’ but argument is of type ‘int’
    3 | void trocar(int *a, int *b) {
      |                     ~~~~~^

#include <stdio.h>

int *criar_nota(void) {
    int nota = 9;
    return &nota;
}

int main(void) {
    int *p = criar_nota();
    printf("p = %p\n", (void *) p);
    printf("nota = %d\n", *p);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra local.c -o local
local.c: In function ‘criar_nota’:
local.c:5:12: warning: function returns address of local variable [-Wreturn-local-addr]
    5 |     return &nota;
      |            ^~~~~
$ ./local
p = (nil)
Falha de segmentação     (imagem do núcleo gravada) ./local

Referência rápida

Exercícios

Missão final: o menor e o maior

Menor: 3
Maior: 9

#include <stdio.h>

void min_max(int *v, int n, int *menor, int *maior) {
    // guarde a menor nota em *menor e a maior em *maior
}

int main(void) {
    int notas[6] = {7, 3, 9, 6, 8, 5};
    int menor = 0;
    int maior = 0;

    min_max(notas, 6, &menor, &maior);
    printf("Menor: %d\n", menor);
    printf("Maior: %d\n", maior);
    return 0;
}

#include <stdio.h>

void min_max(int *v, int n, int *menor, int *maior) {
    *menor = v[0];
    *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 main(void) {
    int notas[6] = {7, 3, 9, 6, 8, 5};
    int menor = 0;
    int maior = 0;

    min_max(notas, 6, &menor, &maior);
    printf("Menor: %d\n", menor);
    printf("Maior: %d\n", maior);
    return 0;
}

Resumo

• Em C, todo argumento vai por valor: a função recebe uma cópia. Mudar a cópia não muda o original.
• Para uma função mudar uma variável sua, passe o endereço: parâmetro int *x, uso *x, chamada f(&x).
• A troca clássica: void trocar(int *a, int *b) { int t = *a; *a = *b; *b = t; }.
• O scanf precisa do & pelo mesmo motivo. Sem ele, o gcc avisa e o programa pode morrer (ou, no editor, seguir com o valor errado).
• Ponteiros permitem devolver vários resultados, e o padrão "return diz se deu certo + resultado por ponteiro" é comum.
• Nunca devolva o endereço de uma variável local: ela some quando a função termina.
• Próxima aula: Ponteiros e Strings.