Aritmética de Punteros

Parte de la sección Logic & Flow del Journey de C de Coddy — lección 9 de 63.

Has aprendido a acceder a los elementos de un array utilizando la notación de punteros como *(array + i). Ahora descubrirás una técnica aún más potente: aritmética de punteros, que te permite mover punteros a través de la memoria utilizando operaciones simples de incremento y decremento.

Cuando incrementas un puntero con ++ o lo decrementas con --, el puntero no se mueve simplemente un byte. En su lugar, se mueve según el tamaño del tipo de dato al que apunta. Para un puntero de entero, ptr++ se desplaza hacia adelante sizeof(int) bytes, aterrizando exactamente en el siguiente entero en memoria.

int numbers[5] = {10, 20, 30, 40, 50};
int *ptr = numbers;    // Apunta al primer elemento (10)
ptr++;                 // Ahora apunta al segundo elemento (20)
ptr++;                 // Ahora apunta al tercer elemento (30)

Este cálculo automático del tamaño es lo que hace que la aritmética de punteros sea tan potente y conveniente. No necesitas preocuparte por los cálculos de bytes; C se encarga del direccionamiento de memoria por ti basándose en el tipo de datos del puntero.

La aritmética de punteros es particularmente útil para recorrer arreglos en bucles. En lugar de usar índices de arreglos, puedes incrementar un puntero para moverte a través de cada elemento secuencialmente, lo que a menudo resulta en un código más eficiente.

Desafío

Fácil

Escribe un programa en C que demuestre la aritmética de punteros utilizando operaciones de incremento de punteros para recorrer y procesar un arreglo. Tu programa debe:

Declarar un arreglo de enteros llamado data con 5 elementos e inicializarlo con los valores {12, 24, 36, 48, 60}
Declarar un puntero a un entero llamado ptr e inicializarlo para que apunte al primer elemento del arreglo
Usar un bucle for que se ejecute 5 veces para recorrer todo el arreglo utilizando únicamente aritmética de punteros
Dentro del bucle:
- Imprimir el valor actual al que apunta ptr utilizando el operador de desreferencia
- Imprimir la dirección de memoria almacenada en ptr utilizando el especificador de formato %p
- Incrementar el puntero usando ptr++ para moverse al siguiente elemento
Después del bucle, restablecer ptr para que apunte de nuevo al primer elemento del arreglo
Usar aritmética de punteros para acceder directamente e imprimir el tercer elemento (índice 2) usando *(ptr + 2)
Usar aritmética de punteros para acceder directamente e imprimir el último elemento (índice 4) usando *(ptr + 4)

Tu salida debe mostrar los resultados en el siguiente 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 desafío pone a prueba tu comprensión de cómo las operaciones de incremento de punteros se mueven automáticamente según el tamaño del tipo de dato, y cómo puedes usar la aritmética de punteros para acceder a los elementos de un arreglo en desplazamientos específicos desde la posición de un puntero base.

Hoja de referencia

La aritmética de punteros le permite mover punteros a través de la memoria utilizando operaciones de incremento y decremento. Cuando incrementa un puntero, este se mueve según el tamaño del tipo de dato al que apunta, no por un solo byte.

Operaciones básicas de aritmética de punteros:

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)

También puede utilizar la aritmética de punteros para acceder a elementos en desplazamientos (offsets) específicos:

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

La aritmética de punteros es útil para recorrer arreglos en bucles, lo que a menudo resulta en un código más eficiente que el uso de índices de arreglo.

Pruébalo tú mismo

#include <stdio.h>

int main() {
    // TODO: Escribe tu código aquí
    // Declarar e inicializar el arreglo 'data' con los valores {12, 24, 36, 48, 60}
    // Declarar el puntero 'ptr' e inicializarlo para que apunte al primer elemento
    // Usar un bucle for con aritmética de punteros para recorrer el arreglo
    // Imprimir cada valor y dirección, luego incrementar el puntero
    // Restablecer el puntero y usar aritmética de punteros para acceder a elementos específicos
    
    return 0;
}

Ponte a prueba

Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.

Todas las lecciones de Logic & Flow

2Punteros y Arrays

Nombres de Arrays como Punteros Elementos de un Array - PunterosAritmética de PunterosComparación de Punteros Resumen: Recorrido de Arrays con Punteros

5Punteros y funciones

Paso por valor Pasar punteros a funciones Modificar variables mediante punteros Un ejemplo clásico: Intercambio (Swap)Pasar arrays a funciones Resumen: Argumentos de punteros a funciones

8Estructuras y Punteros

Punteros a estructuras El operador flecha (->)Pasar estructuras por valor Pasar punteros a estructuras Asignación dinámica de estructuras Resumen: Modificar estructuras - Ptr

11Desafíos de repaso final

Repaso: Concatenación dinámica de strings Repaso: Array de structs Repaso: Contador de frecuencia de palabras