C Ponteiros e Arrays

Em C, ponteiros e arrays são parentes muito próximos. Tão próximos que, na maior parte do tempo, o nome de um array se comporta como um ponteiro, e um ponteiro pode ser usado com colchetes, como um array. Entender esse parentesco explica várias coisas que pareciam mágica: por que uma função consegue mudar os itens de um array que você passou, por que o sizeof "erra" dentro de uma função e como andar de item em item somando ao ponteiro.

Os programas foram compilados na máquina da Ana, na pasta ~/c, com gcc -std=c23 -Wall -Wextra arquivo.c -o programa. Antes de continuar, tenha frescas as aulas Arrays e Ponteiros.

A ideia: casas numa rua, sem buracos

Pense numa rua em que as casas têm todas o mesmo tamanho e ficam coladas, uma depois da outra. Se você sabe onde fica a primeira casa, sabe onde ficam todas: "a terceira casa fica duas casas depois da primeira". Você não precisa de um papel com o endereço de cada uma: um papel com o endereço da primeira basta.

Um array é essa rua. Você viu em Memória e Endereços que os itens moram em gavetas vizinhas, sem buracos. Um ponteiro para o primeiro item é o papel com o endereço da primeira casa. A partir dele, "andar duas casas" é uma conta.

1. O nome do array vira ponteiro

#include <stdio.h>

int main(void) {
    int notas[4] = {7, 8, 6, 9};
    int *p = notas;

    printf("notas     = %p\n", (void *) notas);
    printf("&notas[0] = %p\n", (void *) &notas[0]);
    printf("p         = %p\n", (void *) p);
    printf("*p = %d\n", *p);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra nome.c -o nome
$ ./nome
notas     = 0x7fff31424a00
&notas[0] = 0x7fff31424a00      « o mesmo endereço
p         = 0x7fff31424a00
*p = 7                          « p aponta para o primeiro item

Repare na linha int *p = notas;: não tem &. Quando você usa o nome de um array numa expressão, o C o troca automaticamente pelo endereço do primeiro item. Em inglês, isso se chama array decay ("o array decai", vira ponteiro). As duas linhas abaixo fazem a mesma coisa:

int *p = notas;        // o nome do array vira &notas[0]
int *p = &notas[0];    // escrito por extenso

2. p + 1 anda um item, não um byte

Somar um número a um ponteiro é chamado de aritmética de ponteiros. A regra que surpreende: p + 1 não é "o endereço seguinte", é "o item seguinte". O compilador multiplica o 1 pelo tamanho do tipo apontado:

#include <stdio.h>

int main(void) {
    int notas[4] = {7, 8, 6, 9};
    double precos[3] = {4.5, 3.0, 12.9};
    int *p = notas;
    double *q = precos;

    printf("p     = %p   *p     = %d\n", (void *) p, *p);
    printf("p + 1 = %p   *(p+1) = %d\n", (void *) (p + 1), *(p + 1));
    printf("p + 2 = %p   *(p+2) = %d\n", (void *) (p + 2), *(p + 2));
    printf("q     = %p   *q     = %.2f\n", (void *) q, *q);
    printf("q + 1 = %p   *(q+1) = %.2f\n", (void *) (q + 1), *(q + 1));
    return 0;
}

$ gcc -std=c23 -Wall -Wextra passo.c -o passo
$ ./passo
p     = 0x7ffc5828d0e0   *p     = 7
p + 1 = 0x7ffc5828d0e4   *(p+1) = 8        « +4 bytes: um int
p + 2 = 0x7ffc5828d0e8   *(p+2) = 6        « +8 bytes: dois ints
q     = 0x7ffc5828d0f0   *q     = 4.50
q + 1 = 0x7ffc5828d0f8   *(q+1) = 3.00     « +8 bytes: um double

É por isso que o tipo do ponteiro importa tanto: ele diz o tamanho do passo. Com int *, cada passo é de 4 bytes; com double *, de 8; com char *, de 1. Se p + 1 andasse só um byte, cairia no meio do item, o que não teria sentido nenhum.

Primeira nota: 7
Terceira nota: 6

#include <stdio.h>

int main(void) {
    int notas[4] = {7, 8, 6, 9};
    int *p = notas;

    printf("Primeira nota: %d\n", *p);
    // mostre "Terceira nota: " e o item de índice 2, pelo p

    return 0;
}

#include <stdio.h>

int main(void) {
    int notas[4] = {7, 8, 6, 9};
    int *p = notas;

    printf("Primeira nota: %d\n", *p);
    printf("Terceira nota: %d\n", *(p + 2));

    return 0;
}

Os parênteses importam

*(p + 2) e *p + 2 são coisas diferentes. O * vem antes do + na precedência:

3. p[i] é *(p + i)

Aqui está o segredo dos colchetes: em C, a[i] é definido como *(a + i). Os colchetes são só um jeito mais bonito de escrever "ande i itens e pegue o valor". Por isso eles funcionam tanto no nome do array quanto num ponteiro:

#include <stdio.h>

int main(void) {
    int notas[4] = {7, 8, 6, 9};
    int *p = notas;

    for (int i = 0; i < 4; i++) {
        printf("i=%d  notas[i]=%d  *(notas+i)=%d  p[i]=%d  *(p+i)=%d\n",
               i, notas[i], *(notas + i), p[i], *(p + i));
    }
    return 0;
}

$ gcc -std=c23 -Wall -Wextra colchete.c -o colchete
$ ./colchete
i=0  notas[i]=7  *(notas+i)=7  p[i]=7  *(p+i)=7
i=1  notas[i]=8  *(notas+i)=8  p[i]=8  *(p+i)=8
i=2  notas[i]=6  *(notas+i)=6  p[i]=6  *(p+i)=6
i=3  notas[i]=9  *(notas+i)=9  p[i]=9  *(p+i)=9

As quatro formas dão sempre o mesmo valor. Isso também explica por que os índices começam em 0: o índice é a distância desde o primeiro item. O primeiro está a 0 passos dele mesmo.

4. Percorrer um array com um ponteiro

Em vez de um índice i que vai de 0 a 3, dá para usar um ponteiro que começa no primeiro item e vai andando, um item por vez, até passar do último:

#include <stdio.h>

int main(void) {
    int notas[4] = {7, 8, 6, 9};
    int soma = 0;

    for (int *p = notas; p < notas + 4; p++) {
        printf("p aponta para %p, que guarda %d\n", (void *) p, *p);
        soma += *p;
    }
    printf("Soma: %d\n", soma);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra percorrer.c -o percorrer
$ ./percorrer
p aponta para 0x7ffe5748e290, que guarda 7
p aponta para 0x7ffe5748e294, que guarda 8
p aponta para 0x7ffe5748e298, que guarda 6
p aponta para 0x7ffe5748e29c, que guarda 9
Soma: 30

int *p = notas;

Começo: o ponteiro aponta para o primeiro item.

p < notas + 4;

Condição: notas + 4 é o endereço logo depois do último item (o "fim" da rua). Enquanto p estiver antes dele, ainda há item para ler. Ponteiros podem ser comparados com < quando apontam para o mesmo array. Apontar para "um depois do último" é permitido; ler ali (*(notas + 4)) não.

p++

Passo: anda um item (4 bytes, porque é int *).

*p

O item atual.

Qual usar, índice ou ponteiro? Para o computador, tanto faz: o gcc gera praticamente o mesmo código. Para quem lê, o for com índice (notas[i]) costuma ser mais claro, e é o que você deve preferir. Percorrer com ponteiro aparece muito em código C de verdade, principalmente com strings, então é importante saber ler.

A distância entre dois ponteiros

Assim como dá para somar um número a um ponteiro, dá para subtrair dois ponteiros do mesmo array. O resultado é quantos itens há entre eles (e não quantos bytes):

#include <stdio.h>

int main(void) {
    int notas[5] = {7, 8, 6, 9, 10};
    int *inicio = notas;
    int *maior = &notas[4];

    printf("maior - inicio = %td itens\n", maior - inicio);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra distancia.c -o distancia
$ ./distancia
maior - inicio = 4 itens         « 16 bytes ÷ 4 bytes por int

O resultado da subtração é do tipo ptrdiff_t ("diferença de ponteiros"), e o formato do printf para ele é %td. Somar dois ponteiros, por outro lado, não faz sentido (somar dois endereços de casas não dá endereço nenhum) e é erro.

5. sizeof: array × ponteiro

A exceção mais importante à regra "o nome vira ponteiro" é o sizeof. Com o nome do array, ele mede o array inteiro. Com um ponteiro, mede só o ponteiro, o "papel com o endereço":

#include <stdio.h>

void mostrar(int notas[]) {
    printf("Na função: sizeof(notas) = %zu\n", sizeof(notas));
}

int main(void) {
    int notas[4] = {7, 8, 6, 9};
    int *p = notas;

    printf("No main:   sizeof(notas) = %zu\n", sizeof(notas));
    printf("No main:   sizeof(p)     = %zu\n", sizeof(p));
    mostrar(notas);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra tamanho.c -o tamanho
tamanho.c: In function ‘mostrar’:
tamanho.c:4:54: warning: ‘sizeof’ on array function parameter ‘notas’ will return size of ‘int *’ [-Wsizeof-array-argument]
    4 |     printf("Na função: sizeof(notas) = %zu\n", sizeof(notas));
      |                                                      ^
tamanho.c:3:18: note: declared here
    3 | void mostrar(int notas[]) {
      |              ~~~~^~~~~~~
$ ./tamanho
No main:   sizeof(notas) = 16        « o array: 4 itens × 4 bytes
No main:   sizeof(p)     = 8         « o ponteiro: um endereço
Na função: sizeof(notas) = 8         « na função, notas já é um ponteiro!

A terceira linha é a surpresa. Quando você passa um array para uma função, o que viaja é só o endereço do primeiro item (o nome "virou ponteiro" na chamada). Dentro da função, int notas[] é só outro jeito de escrever int *notas. O array de verdade ficou no main. O gcc percebe e avisa: "o sizeof num parâmetro de array vai devolver o tamanho de int *". No editor do guia, os números são 16, 4 e 4 (lá um ponteiro ocupa 4 bytes), e o Clang avisa do mesmo jeito.

A armadilha: contar itens dentro da função

A conta sizeof(notas) / sizeof(notas[0]), que descobre quantos itens um array tem, dá resultado errado dentro de uma função:

#include <stdio.h>

double media(int notas[]) {
    int n = sizeof(notas) / sizeof(notas[0]);
    int soma = 0;
    for (int i = 0; i < n; i++) {
        soma += notas[i];
    }
    printf("(a função acha que são %d notas)\n", n);
    return (double) soma / n;
}

int main(void) {
    int notas[5] = {7, 8, 6, 9, 10};
    printf("Média: %.2f\n", media(notas));
    return 0;
}

$ gcc -std=c23 -Wall -Wextra armadilha.c -o armadilha
armadilha.c: In function ‘media’:
armadilha.c:4:19: warning: ‘sizeof’ on array function parameter ‘notas’ will return size of ‘int *’ [-Wsizeof-array-argument]
    4 |     int n = sizeof(notas) / sizeof(notas[0]);
      |                   ^
armadilha.c:3:18: note: declared here
    3 | double media(int notas[]) {
      |              ~~~~^~~~~~~
$ ./armadilha
(a função acha que são 2 notas)      « 8 bytes do ponteiro ÷ 4 bytes do int
Média: 7.50                          « a média só de 7 e 8. A certa é 8.00

Nenhuma falha, nenhuma mensagem de erro: só um resultado errado, que passaria despercebido se você não conferisse. No editor, a função acha que é 1 nota (4 ÷ 4) e mostra Média: 7.00. O conserto é a regra de ouro das funções que recebem arrays em C: mande o tamanho junto, contado no lugar onde o array de verdade existe:

#include <stdio.h>

double media(int *notas, int n) {
    int soma = 0;
    for (int i = 0; i < n; i++) {
        soma += notas[i];
    }
    return (double) soma / n;
}

int main(void) {
    int notas[5] = {7, 8, 6, 9, 10};
    int n = sizeof(notas) / sizeof(notas[0]);

    printf("Média: %.2f\n", media(notas, n));
    return 0;
}

$ gcc -std=c23 -Wall -Wextra media.c -o media
$ ./media
Média: 8.00

Repare que o parâmetro agora está escrito como int *notas, que é o que ele realmente é. int notas[] também funcionaria (é o mesmo tipo), mas engana quem lê. Dentro da função, notas[i] continua funcionando, porque p[i] vale para qualquer ponteiro.

Formas de passar um array para uma função: qual usar

Como a função recebe um ponteiro para os itens originais, ela pode mudá-los (o main vê a mudança). Quando a função só precisa ler, a aula const e Ponteiros mostra como prometer isso com const int *v.

Quando dá errado

#include <stdio.h>

int main(void) {
    int notas[4] = {7, 8, 6, 9};
    int outras[4] = {1, 2, 3, 4};

    notas = outras;
    notas++;
    printf("%d\n", notas[0]);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra atribuir.c -o atribuir
atribuir.c: In function ‘main’:
atribuir.c:7:11: error: assignment to expression with array type
    7 |     notas = outras;
      |           ^
atribuir.c:8:10: error: lvalue required as increment operand
    8 |     notas++;
      |          ^~

$ gcc -std=c23 -Wall -Wextra armadilha.c -o armadilha
armadilha.c: In function ‘media’:
armadilha.c:4:19: warning: ‘sizeof’ on array function parameter ‘notas’ will return size of ‘int *’ [-Wsizeof-array-argument]
    4 |     int n = sizeof(notas) / sizeof(notas[0]);
      |                   ^

Referência rápida

Exercícios

Missão final: a média de qualquer turma

Turma A: 8.00
Turma B: 6.50

#include <stdio.h>

// escreva aqui: double media(int *v, int n) { ... }

int main(void) {
    int turma_a[5] = {7, 8, 6, 9, 10};
    int turma_b[2] = {5, 8};

    printf("Turma A: %.2f\n", media(turma_a, 5));
    printf("Turma B: %.2f\n", media(turma_b, 2));
    return 0;
}

#include <stdio.h>

double media(int *v, int n) {
    int soma = 0;
    for (int i = 0; i < n; i++) {
        soma += v[i];
    }
    return (double) soma / n;
}

int main(void) {
    int turma_a[5] = {7, 8, 6, 9, 10};
    int turma_b[2] = {5, 8};

    printf("Turma A: %.2f\n", media(turma_a, 5));
    printf("Turma B: %.2f\n", media(turma_b, 2));
    return 0;
}

Resumo

• O nome de um array, numa expressão, vira o endereço do primeiro item: int *p = notas; é o mesmo que int *p = &notas[0];.
• p + 1 anda um item (4 bytes para int, 8 para double), e não um byte.
• p[i] é, por definição, *(p + i). Os colchetes funcionam em arrays e em ponteiros.
• Dá para percorrer um array com for (int *p = v; p < v + n; p++), mas o índice costuma ser mais claro.
• sizeof do array mede tudo; sizeof do ponteiro mede só o endereço. Numa função, o "array" recebido é um ponteiro: mande o tamanho junto.
• Um array não pode ser atribuído nem andar (notas++ é erro). E o C não confere se você passou do fim.
• Próxima aula: Passar por Ponteiro, funções que mudam variáveis de quem as chamou.