Aula 21 — Aritmética de Ponteiros

1. O que é Aritmética de Ponteiros?

Você já sabe que um ponteiro armazena um endereço de memória. O que torna os ponteiros em C especialmente poderosos é que você pode fazer contas com esses endereços — somar, subtrair e comparar — de forma inteligente e segura.

Por que o compilador escala automaticamente?

Se um int ocupa 4 bytes e você tem um array int v[5], os elementos estão nos endereços:

Ao escrever p + 1, o compilador sabe que deve avançar 1 × sizeof(int) = 4 bytes, e não apenas 1 byte. Isso é a escala automática — você pensa em elementos, não em bytes.

2. Incremento e Decremento: p++ e p--

As operações mais comuns em aritmética de ponteiros são o incremento (++) e o decremento (--), que avançam ou recuam o ponteiro por um elemento:

#include <stdio.h>

int main() {
    int v[] = {10, 20, 30, 40, 50};
    int *p = v;          // p aponta para v[0]

    printf("*p    = %d  (endereço %p)\n", *p, p);   // 10

    p++;                 // avança 4 bytes → aponta para v[1]
    printf("*p++  = %d  (endereço %p)\n", *p, p);   // 20

    p++;                 // avança mais 4 bytes → v[2]
    printf("*p++  = %d  (endereço %p)\n", *p, p);   // 30

    p--;                 // recua 4 bytes → v[1]
    printf("*p--  = %d  (endereço %p)\n", *p, p);   // 20

    return 0;
}

O tamanho do passo depende do tipo

3. Soma e Subtração com Inteiro

p + n produz um novo ponteiro que aponta n elementos à frente de p, sem mover p:

#include <stdio.h>

int main() {
    float notas[] = {6.5f, 7.0f, 8.5f, 9.0f, 5.5f};
    float *inicio = notas;             // aponta para notas[0]

    printf("notas[0] = %.1f\n", *inicio);
    printf("notas[2] = %.1f\n", *(inicio + 2));  // avança 2×4 = 8 bytes
    printf("notas[4] = %.1f\n", *(inicio + 4));  // avança 4×4 = 16 bytes

    /* inicio ainda aponta para notas[0] — não foi modificado */
    printf("inicio ainda = %.1f\n", *inicio);

    /* Navegando com += */
    float *p = notas;
    p += 3;                            // agora aponta para notas[3]
    printf("após p+=3: %.1f\n", *p);

    return 0;
}

int v[] = {10, 20, 30, 40, 50};
int *p = v;

/* Estas quatro formas são idênticas — geram o mesmo código */
printf("%d\n", v[2]);       // notação de array com nome
printf("%d\n", p[2]);       // notação de array com ponteiro
printf("%d\n", *(v + 2));   // aritmética com nome do array
printf("%d\n", *(p + 2));   // aritmética com ponteiro

4. Subtração entre Ponteiros — Distância em Elementos

Quando você subtrai dois ponteiros do mesmo tipo que apontam para posições dentro do mesmo array, o resultado é a distância em número de elementos (não em bytes) entre eles:

#include <stdio.h>

int main() {
    int v[] = {10, 20, 30, 40, 50};
    int *inicio = &v[0];
    int *fim    = &v[4];

    printf("fim - inicio = %ld elementos\n", fim - inicio);  // 4
    printf("distância em bytes: %ld\n",
           (char*)fim - (char*)inicio);                       // 16

    /* Encontrar posição de um elemento */
    int *p = &v[2];
    printf("v[2] está na posição %ld do array\n", p - v);    // 2

    return 0;
}

5. Comparação de Ponteiros

Ponteiros do mesmo array podem ser comparados com ==, !=, <, >, <=, >=. Um ponteiro menor aponta para uma posição anterior na memória:

#include <stdio.h>

int main() {
    int v[] = {10, 20, 30, 40, 50};
    int *p = &v[1];
    int *q = &v[3];

    printf("p < q? %s\n",  p < q  ? "sim" : "não");   // sim
    printf("p == q? %s\n", p == q ? "sim" : "não");   // não

    /* Percorrer array com dois ponteiros convergindo */
    int *esq = v;
    int *dir = v + 4;

    printf("\nPercurso convergente: ");
    while (esq <= dir) {
        printf("%d ", *esq);
        esq++;
    }
    printf("\n");

    return 0;
}

Comparar com NULL — o teste mais importante

int *p = NULL;

if (p == NULL)
    printf("ponteiro inválido — não use!\n");
else
    printf("valor: %d\n", *p);    // só desreferencia se não for NULL

6. Percorrendo Arrays com Ponteiros

Uma das aplicações mais comuns de aritmética de ponteiros é percorrer arrays de forma eficiente — especialmente em funções que recebem arrays como parâmetros:

Estilo clássico com índice vs. estilo com ponteiro

void imprimirV1(int v[], int n) {
    for (int i = 0; i < n; i++)
        printf("%d ", v[i]);
    printf("\n");
}

void imprimirV2(int *p, int n) {
    int *fim = p + n;
    while (p < fim)
        printf("%d ", *p++);
    printf("\n");
}

Ambas produzem o mesmo resultado. A versão com ponteiro usa *p++: primeiro lê *p (desreferencia) e depois incrementa o ponteiro — tudo numa única expressão.

Exemplo completo: operações com ponteiros em array

#include <stdio.h>

/* Soma todos os elementos usando aritmética de ponteiros */
int somarArray(const int *p, int n) {
    int soma = 0;
    const int *fim = p + n;
    while (p < fim)
        soma += *p++;
    return soma;
}

/* Encontra o maior elemento, retorna ponteiro para ele */
int *encontrarMaior(int *p, int n) {
    int *maior = p;
    int *fim   = p + n;
    p++;
    while (p < fim) {
        if (*p > *maior)
            maior = p;
        p++;
    }
    return maior;
}

/* Inverte o array no próprio lugar usando dois ponteiros */
void inverter(int *esq, int *dir) {
    while (esq < dir) {
        int temp = *esq;
        *esq = *dir;
        *dir = temp;
        esq++;
        dir--;
    }
}

int main() {
    int v[] = {3, 7, 1, 9, 4, 6, 2};
    int n = 7;

    printf("Array:  ");
    for (int i = 0; i < n; i++) printf("%d ", v[i]);
    printf("\n");

    printf("Soma:   %d\n", somarArray(v, n));

    int *pm = encontrarMaior(v, n);
    printf("Maior:  %d (posição %ld)\n", *pm, pm - v);

    inverter(v, v + n - 1);
    printf("Invertido: ");
    for (int i = 0; i < n; i++) printf("%d ", v[i]);
    printf("\n");

    return 0;
}

7. Aritmética de Ponteiros em Strings

Strings em C são arrays de char terminados com '\0'. A aritmética de ponteiros é a base de praticamente todas as operações com strings na linguagem:

#include <stdio.h>

/* Calcula o comprimento de uma string sem usar strlen */
int meuStrlen(const char *s) {
    const char *p = s;
    while (*p != '\0')   // avança até o terminador nulo
        p++;
    return p - s;        // distância em caracteres
}

/* Copia uma string sem usar strcpy */
void meuStrcpy(char *dest, const char *src) {
    while ((*dest++ = *src++) != '\0')  // copia e avança os dois ponteiros
        ;
}

int main() {
    char saudacao[] = "Olá, C!";
    printf("String:     %s\n",  saudacao);
    printf("Comprimento: %d\n", meuStrlen(saudacao));

    char copia[20];
    meuStrcpy(copia, saudacao);
    printf("Cópia:      %s\n",  copia);

    /* Avançando manualmente em uma string */
    const char *p = "abcdef";
    printf("\nCaracteres: ");
    while (*p)                    // *p != '\0' pode ser escrito como *p
        printf("%c ", *p++);
    printf("\n");

    /* Pulando para a segunda palavra */
    const char *frase = "Bom dia!";
    const char *q = frase;
    while (*q != ' ') q++;        // avança até o espaço
    q++;                           // pula o espaço
    printf("Segunda palavra: %s\n", q);

    return 0;
}

8. Limites e Cuidados

Aritmética de ponteiros é poderosa, mas silenciosamente perigosa quando usada fora dos limites válidos:

int v[5] = {10, 20, 30, 40, 50};
int *p;

/* ✅ Válido — percorrer com ponteiro sentinela (v+5) */
for (p = v; p < v + 5; p++)
    printf("%d ", *p);

/* ❌ INVÁLIDO — desreferenciar v+5 é comportamento indefinido */
p = v + 5;
printf("%d\n", *p);   // acessa memória além do array!

/* ❌ INVÁLIDO — ponteiro antes do início */
p = v - 1;
printf("%d\n", *p);   // comportamento indefinido

9. Ponteiro para Ponteiro (**)

Um ponteiro pode apontar para outro ponteiro. Isso é usado em funções que precisam modificar o próprio ponteiro do chamador (não apenas o valor apontado), e em arrays de strings:

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

/* Aloca um array e faz o ponteiro do chamador apontar para ele */
void alocarArray(int **pp, int n) {
    *pp = (int *) malloc(n * sizeof(int));   // modifica o ponteiro original
    if (*pp == NULL) return;
    for (int i = 0; i < n; i++)
        (*pp)[i] = (i + 1) * 10;
}

int main() {
    int *vetor = NULL;

    alocarArray(&vetor, 5);   // passa &vetor → função recebe int **

    if (vetor != NULL) {
        printf("Array alocado: ");
        for (int i = 0; i < 5; i++)
            printf("%d ", vetor[i]);
        printf("\n");
        free(vetor);
    }

    /* Array de strings — cada elemento é um char* */
    const char *dias[] = {
        "Segunda", "Terça", "Quarta",
        "Quinta",  "Sexta", "Sábado", "Domingo"
    };
    int total = 7;

    printf("\nDias da semana:\n");
    for (int i = 0; i < total; i++)
        printf("  dias[%d] = %s\n", i, dias[i]);

    return 0;
}

10. C vs. Java — Aritmética de Ponteiros

Side-by-side: percorrer array

int v[] = {1, 2, 3, 4, 5};
int *p = v;
int *fim = v + 5;

while (p < fim)
    printf("%d ", *p++);

int[] v = {1, 2, 3, 4, 5};

for (int x : v)
    System.out.print(x + " ");

// Java abstrai completamente
// a posição na memória