Comparación de Punteros

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

Has aprendido a moverte a través de arreglos utilizando aritmética de punteros. Ahora descubrirás que los punteros también pueden ser comparados utilizando los mismos operadores relacionales que usas con variables regulares: ==, !=, <, y >.

Cuando comparas dos punteros, estás comparando sus direcciones de memoria. Esto es particularmente útil cuando ambos punteros apuntan a elementos dentro del mismo arreglo, ya que te permite determinar sus posiciones relativas en la memoria.

int numbers[5] = {10, 20, 30, 40, 50};
int *start = numbers;        // Apunta al primer elemento
int *end = numbers + 4;      // Apunta al último elemento

if (start < end) {
    printf("start comes before end in memory");
}

La comparación de punteros se vuelve especialmente poderosa en las condiciones de los bucles. En lugar de usar una variable de contador, puedes comparar la posición actual de tu puntero con un puntero de destino para controlar cuándo debe detenerse el bucle. Esto crea un código elegante y eficiente para el recorrido de arreglos.

La idea clave es que ptr1 < ptr2 le indica que ptr1 apunta a un elemento que aparece antes en el arreglo que el elemento al que ptr2 apunta. Esta relación hace que la comparación de punteros sea ideal para controlar bucles que procesan arreglos de forma secuencial.

Desafío

Fácil

Escribe un programa en C que utilice la comparación de punteros para recorrer un arreglo y encontrar elementos dentro de un rango específico. Tu programa debe:

Declarar un arreglo de enteros llamado scores con 8 elementos e inicializarlo con los valores {45, 78, 92, 63, 87, 34, 91, 56}
Declarar dos punteros a enteros: start_ptr y end_ptr
Configurar start_ptr para que apunte al primer elemento del arreglo
Configurar end_ptr para que apunte al último elemento del arreglo utilizando aritmética de punteros
Declarar un puntero llamado current_ptr e inicializarlo para que apunte al primer elemento
Usar un bucle while con comparación de punteros (current_ptr <= end_ptr) para recorrer el arreglo
Dentro del bucle:
- Comprobar si el valor actual está entre 60 y 90 (inclusive)
- Si el valor está en el rango, imprimir "Value %d is in range"
- Si el valor no está en el rango, imprimir "Value %d is out of range"
- Incrementar current_ptr para moverse al siguiente elemento
Después del bucle, usar la comparación de punteros para verificar que current_ptr está ahora más allá del final del arreglo comprobando si current_ptr > end_ptr
Si la condición es verdadera, imprimir "Traversal complete"

Tu salida debe mostrar los resultados en el siguiente formato:

Value 45 is out of range
Value 78 is in range
Value 92 is out of range
Value 63 is in range
Value 87 is in range
Value 34 is out of range
Value 91 is out of range
Value 56 is out of range
Traversal complete

Este desafío pone a prueba tu comprensión de los operadores de comparación de punteros en condiciones de bucle, el uso de la aritmética de punteros para establecer punteros de límite y cómo la comparación de punteros puede controlar el recorrido de un arreglo de manera más elegante que los bucles tradicionales basados en contadores.

Hoja de referencia

Los punteros se pueden comparar utilizando operadores relacionales: ==, !=, < y >.

Al comparar punteros, se están comparando sus direcciones de memoria. Esto es útil para determinar las posiciones relativas de los elementos dentro de un mismo array.

int numbers[5] = {10, 20, 30, 40, 50};
int *start = numbers;        // Points to first element
int *end = numbers + 4;      // Points to last element

if (start < end) {
    printf("start comes before end in memory");
}

La comparación de punteros es particularmente potente en las condiciones de los bucles, lo que permite controlar los bucles comparando las posiciones de los punteros en lugar de utilizar variables de contador:

int *current_ptr = numbers;
int *end_ptr = numbers + 4;

while (current_ptr <= end_ptr) {
    // Process current element
    current_ptr++;  // Move to next element
}

La expresión ptr1 < ptr2 significa que ptr1 apunta a un elemento que aparece antes en el array que el elemento al que apunta ptr2.

Pruébalo tú mismo

#include <stdio.h>

int main() {
    // TODO: Escribe tu código a continuación
    
    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 - Punteros Aritmética de PunterosComparación de PunterosResumen: 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