Menu
Coddy logo textTech

Punteros y arrays

Parte de la sección Lógica y Flujo del Journey de C++ de Coddy — lección 5 de 56.

Los arreglos y los punteros tienen una relación especial en C++. Cuando declaras un arreglo, el nombre del arreglo actúa en realidad como un puntero al primer elemento de ese arreglo. Esta conexión te permite usar punteros para trabajar con arreglos de formas poderosas.

Considera esta declaración de array:

int numbers[5] = {10, 20, 30, 40, 50};
int* ptr = numbers;  // ptr ahora apunta a numbers[0]

Aquí, numbers es equivalente a &numbers[0] - ambos te dan la dirección del primer elemento. El puntero ptr ahora apunta a la misma ubicación.

Una vez que tienes un puntero a un array, puedes usar aritmética de punteros para navegar a través de los elementos. Sumar 1 a un puntero lo mueve al siguiente elemento del mismo tipo:

ptr++;        // Ahora apunta a numbers[1]
ptr = ptr + 2; // Ahora apunta a numbers[3]

Puedes desreferenciar el puntero en cualquier posición para acceder al valor: *ptr te da el valor en la posición actual, y *(ptr + 1) te da el valor del siguiente elemento.

Esta relación entre punteros y arreglos le permite iterar a través de arreglos utilizando punteros en lugar de los bucles tradicionales basados en índices, ofreciendo un enfoque alternativo para el recorrido de arreglos.

challenge icon

Desafío

Fácil

Crea un programa que utilice un puntero para iterar a través de un arreglo e imprimir cada elemento, demostrando la relación entre punteros y arreglos.

Se te proporciona el siguiente arreglo:

int values[6] = {15, 23, 8, 42, 17, 31};

Tu programa debe:

  1. Crear un puntero llamado ptr que apunte al primer elemento del arreglo values
  2. Usar aritmética de punteros para iterar a través de los 6 elementos del arreglo
  3. Imprimir cada elemento desreferenciando el puntero en cada posición
  4. Mover el puntero al siguiente elemento usando aritmética de punteros (incrementar el puntero)

Imprime cada elemento en una línea separada con el siguiente formato:

Element: [value]

La salida debe mostrar los 6 elementos en el orden en que aparecen en el arreglo, accedidos a través de la desreferenciación del puntero en lugar de la indexación del arreglo.

Hoja de referencia

Los nombres de los arreglos actúan como punteros al primer elemento. Puedes asignar el nombre de un arreglo directamente a un puntero:

int numbers[5] = {10, 20, 30, 40, 50};
int* ptr = numbers;  // ptr apunta a numbers[0]

Usa aritmética de punteros para navegar a través de los elementos del arreglo:

ptr++;        // Mover al siguiente elemento
ptr = ptr + 2; // Avanzar 2 elementos

Desreferencia el puntero para acceder a los valores:

*ptr          // Valor del elemento actual
*(ptr + 1)    // Valor del siguiente elemento

Esto permite el recorrido de arreglos basado en punteros como una alternativa a los bucles basados en índices.

Pruébalo tú mismo

#include <iostream>
using namespace std;

int main() {
    // Arreglo dado
    int values[6] = {15, 23, 8, 42, 17, 31};
    
    // TODO: Crear un puntero llamado 'ptr' que apunte al primer elemento del arreglo
    
    // TODO: Usar un bucle para iterar a través de los 6 elementos usando aritmética de punteros
    // TODO: Imprimir cada elemento desreferenciando el puntero
    // TODO: Mover el puntero al siguiente elemento usando aritmética de punteros
    
    return 0;
}
quiz iconPonte a prueba

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

Todas las lecciones de Lógica y Flujo