Aritmética de Ponteiros

Parte da seção Logic & Flow do Journey de C da Coddy — lição 9 de 63.

Você aprendeu como acessar elementos de um array usando notação de ponteiro como *(array + i). Agora você descobrirá uma técnica ainda mais poderosa: aritmética de ponteiros, que permite mover ponteiros pela memória usando operações simples de incremento e decremento.

Quando você incrementa um ponteiro com ++ ou o decrementa com --, o ponteiro não se move apenas um byte. Em vez disso, ele se move pelo tamanho do tipo de dado para o qual aponta. Para um ponteiro de inteiro, ptr++ move-se para frente por sizeof(int) bytes, aterrissando exatamente no próximo inteiro na memória.

int numbers[5] = {10, 20, 30, 40, 50};
int *ptr = numbers;    // Aponta para o primeiro elemento (10)
ptr++;                 // Agora aponta para o segundo elemento (20)
ptr++;                 // Agora aponta para o terceiro elemento (30)

Este cálculo automático de tamanho é o que torna a aritmética de ponteiros tão poderosa e conveniente. Você não precisa se preocupar com cálculos de bytes - o C lida com o endereçamento de memória para você com base no tipo de dado do ponteiro.

A aritmética de ponteiros é particularmente útil para percorrer arrays em loops. Em vez de usar índices de array, você pode incrementar um ponteiro para percorrer cada elemento sequencialmente, o que muitas vezes resulta em um código mais eficiente.

Desafio

Fácil

Escreva um programa em C que demonstre a aritmética de ponteiros usando operações de incremento de ponteiro para percorrer e processar um array. Seu programa deve:

Declarar um array de inteiros chamado data com 5 elementos e inicializá-lo com os valores {12, 24, 36, 48, 60}
Declarar um ponteiro para um inteiro chamado ptr e inicializá-lo para apontar para o primeiro elemento do array
Usar um loop for que execute 5 vezes para percorrer todo o array usando apenas aritmética de ponteiros
Dentro do loop:
- Imprimir o valor atual para o qual ptr aponta usando o operador de desreferência
- Imprimir o endereço de memória armazenado em ptr usando o especificador de formato %p
- Incrementar o ponteiro usando ptr++ para mover para o próximo elemento
Após o loop, redefinir ptr para apontar de volta para o primeiro elemento do array
Usar aritmética de ponteiros para acessar e imprimir diretamente o terceiro elemento (índice 2) usando *(ptr + 2)
Usar aritmética de ponteiros para acessar e imprimir diretamente o último elemento (índice 4) usando *(ptr + 4)

Sua saída deve exibir os resultados no seguinte formato:

Value: 12, Address: [address]
Value: 24, Address: [address]
Value: 36, Address: [address]
Value: 48, Address: [address]
Value: 60, Address: [address]
Third element: 36
Last element: 60

Este desafio testa sua compreensão de como as operações de incremento de ponteiro se movem automaticamente pelo tamanho do tipo de dado e como você pode usar a aritmética de ponteiros para acessar elementos de um array em deslocamentos específicos a partir de uma posição de ponteiro base.

Folha de consulta

A aritmética de ponteiros permite que você mova ponteiros pela memória usando operações de incremento e decremento. Quando você incrementa um ponteiro, ele se move pelo tamanho do tipo de dado para o qual aponta, e não por um byte.

Operações básicas de aritmética de ponteiros:

int numbers[5] = {10, 20, 30, 40, 50};
int *ptr = numbers;    // Points to first element (10)
ptr++;                 // Now points to second element (20)
ptr++;                 // Now points to third element (30)

Você também pode usar a aritmética de ponteiros para acessar elementos em deslocamentos (offsets) específicos:

*(ptr + 2)  // Access element at offset 2 from current position

A aritmética de ponteiros é útil para percorrer arrays em loops, resultando frequentemente em um código mais eficiente do que o uso de índices de array.

Experimente você mesmo

#include <stdio.h>

int main() {
    // TODO: Escreva seu código aqui
    // Declare e inicialize o array 'data' com os valores {12, 24, 36, 48, 60}
    // Declare o ponteiro 'ptr' e inicialize-o para apontar para o primeiro elemento
    // Use um loop for com aritmética de ponteiros para percorrer o array
    // Imprima cada valor e endereço, depois incremente o ponteiro
    // Redefina o ponteiro e use aritmética de ponteiros para acessar elementos específicos
    
    return 0;
}

Teste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.

Todas as lições de Logic & Flow

2Ponteiros e Arrays

Nomes de Arrays como Ponteiros Elementos de Array - PonteirosAritmética de PonteirosComparando Ponteiros Recapitulação: Percorrendo Arrays com Ponteiros

5Ponteiros e Funções

Passagem por Valor Passando Ponteiros para Funções Modificando Variáveis via Ponteiros Um Exemplo Clássico: Swap Passando Arrays para Funções Recapitulação: Ponteiros como Argumentos

8Structs e Ponteiros

Ponteiros para Structs O Operador Seta (->)Passagem de Structs por Valor Passagem de Ponteiros para Structs Alocação Dinâmica de Structs Recapitulação: Modificando Struct - Ptr

11Desafios de Revisão Final

Revisão: Concatenação Dinâmica de Strings Revisão: Array de Structs Revisão: Contador de Frequência de Palavras