Punteros y arrays en C++: dominando su relación

Punteros y arrays en C++

En este tutorial, aprenderemos sobre la relación entre arrays y punteros con la ayuda de ejemplos.

En C++, los punteros son variables que almacenan direcciones de otras variables. No solo un puntero puede almacenar la dirección de una sola variable, también puede almacenar la dirección de las celdas de un array.

Considere este ejemplo:

int *ptr;
int arr[5];
// almacenar la dirección del primer elemento de arr en ptr
ptr = arr;

Aquí, ptr es una variable puntero mientras que arr es un array int. El código ptr = arr; almacena la dirección del primer elemento del array en la variable ptr.

Observe que hemos usado arr en lugar de &arr[0]. Esto es porque ambos son lo mismo. Por lo tanto, el código siguiente es el mismo que el anterior.

int *ptr;
int arr[5];
ptr = &arr[0];

Las direcciones para el resto de los elementos del array son dadas por &arr[1], &arr[2], &arr[3] y &arr[4].

---

Apuntar a todos los elementos del array

Supongamos que necesitamos apuntar al cuarto elemento del array usando el mismo puntero ptr.

Aquí, si ptr apunta al primer elemento en el ejemplo anterior, entonces ptr + 3 apuntará al cuarto elemento. Por ejemplo,

int *ptr;
int arr[5];
ptr = arr;
ptr + 1 es equivalente a &arr[1];
ptr + 2 es equivalente a &arr[2];
ptr + 3 es equivalente a &arr[3];
ptr + 4 es equivalente a &arr[4];

De manera similar, podemos acceder a los elementos usando el mismo puntero. Por ejemplo,

// usar operador de desreferencia
*ptr == arr[0];
*(ptr + 1) es equivalente a arr[1];
*(ptr + 2) es equivalente a arr[2];
*(ptr + 3) es equivalente a arr[3];
*(ptr + 4) es equivalente a arr[4];

Supongamos que hemos inicializado ptr = &arr[2]; entonces

ptr - 2 es equivalente a &arr[0];
ptr - 1 es equivalente a &arr[1];
ptr + 1 es equivalente a &arr[3];
ptr + 2 es equivalente a &arr[4];

Nota: La dirección entre ptr y ptr + 1 difiere en 4 bytes. Es porque ptr es un puntero a un dato int. Y el tamaño de int es 4 bytes en un sistema operativo de 64 bits.

De manera similar, si el puntero ptr apunta a datos de tipo char, entonces la dirección entre ptr y ptr + 1 es 1 byte. Es porque el tamaño de un carácter es 1 byte.

---

Ejemplo 1: Punteros y arrays en C++

// Programa en C++ para mostrar la dirección de cada elemento de un array
#include <iostream>
using namespace std;

int main() {
    float arr[3];
    // declarar variable puntero
    float *ptr;
    cout << "Mostrando direcciones usando arrays: " << endl;
    // usar bucle for para imprimir direcciones de todos los elementos del array
    for (int i = 0; i < 3; ++i) {
        cout << "&arr[" << i << "] = " << &arr[i] << endl;
    }
    // ptr = &arr[0]
    ptr = arr;
    cout << "\nMostrando direcciones usando punteros: " << endl;
    // usar bucle for para imprimir direcciones de todos los elementos del array usando notación de punteros
    for (int i = 0; i < 3; ++i) {
        cout << "ptr + " << i << " = " << ptr + i << endl;
    }
    return 0;
}

Salida

Mostrando direcciones usando arrays:
&arr[0] = 0x61fef0
&arr[1] = 0x61fef4
&arr[2] = 0x61fef8
Mostrando direcciones usando punteros:
ptr + 0 = 0x61fef0
ptr + 1 = 0x61fef4
ptr + 2 = 0x61fef8

En el programa anterior, primero simplemente imprimimos las direcciones de los elementos del array sin usar la variable puntero ptr.

Luego, usamos el puntero ptr para apuntar a la dirección de a[0], ptr + 1 para apuntar a la dirección de a[1], y así sucesivamente.

---

En la mayoría de los contextos, los nombres de arrays decaen a punteros. En palabras simples, los nombres de arrays se convierten en punteros. Esa es la razón por la que podemos usar punteros para acceder a elementos de arrays.

Sin embargo, debemos recordar que punteros y arrays no son lo mismo.

Hay algunos casos donde los nombres de arrays no decaen a punteros. Para aprender más, visite: ¿Cuándo el nombre del array no decae en un puntero?

---

Ejemplo 2: Nombre de array usado como puntero

// Programa en C++ para insertar y mostrar datos ingresados usando notación de punteros.
#include <iostream>
using namespace std;

int main() {
    float arr[5];
    // Insertar datos usando notación de punteros
    cout << "Ingrese 5 números: ";
    for (int i = 0; i < 5; ++i) {
        // almacenar número de entrada en arr[i]
        cin >> *(arr + i);
    }
    // Mostrar datos usando notación de punteros
    cout << "Mostrando datos: " << endl;
    for (int i = 0; i < 5; ++i) {
        // mostrar valor de arr[i]
        cout << *(arr + i) << endl;
    }
    return 0;
}

Salida

Ingrese 5 números: 2.5 3.5 4.5 5 2
Mostrando datos:
2.5
3.5
4.5
5
2

Aquí,

1. Primero usamos la notación de punteros para almacenar los números ingresados por el usuario en el array arr.

   cin >> *(arr + i);

   Este código es equivalente al código siguiente:

   cin >> arr[i];

   Observe que no hemos declarado una variable puntero separada, sino que estamos usando el nombre del array arr para la notación de punteros.

   Como ya sabemos, el nombre del array arr apunta al primer elemento del array. Así que podemos pensar en arr como actuando como un puntero.

2. De manera similar, luego usamos un bucle for para mostrar los valores de arr usando notación de punteros.

   cout << *(arr + i) << endl;

   Este código es equivalente a

   cout << arr[i] << endl;