Asignación dinámica de arrays en C++: Guía práctica con ejemplos de código

¿Qué es un array dinámico?

Un array dinámico es bastante similar a un array regular, pero su tamaño es modificable durante la ejecución del programa. Los elementos de un array dinámico ocupan un bloque contiguo de memoria.

Una vez creado un array, su tamaño no puede cambiarse. Sin embargo, un array dinámico es diferente: puede expandir su tamaño incluso después de haber sido llenado.

Durante la creación de un array, se le asigna una cantidad predeterminada de memoria. Esto no ocurre con un array dinámico, ya que aumenta su tamaño de memoria por un factor determinado cuando hay necesidad.

En este tutorial de C++, aprenderá:

• Qué es un array dinámico
• Factores que afectan el rendimiento de arrays dinámicos
• La palabra clave new
• Inicialización de arrays asignados dinámicamente
• Redimensionamiento de arrays
• Eliminación dinámica de arrays

Factores que afectan el rendimiento de arrays dinámicos

El tamaño inicial del array y su factor de crecimiento determinan su rendimiento. Observe los siguientes puntos:

1. Si un array tiene tamaño pequeño y factor de crecimiento pequeño, seguirá reasignando memoria más a menudo. Esto reducirá el rendimiento.
2. Si un array tiene tamaño grande y factor de crecimiento grande, tendrá un gran trozo de memoria sin usar. Las operaciones de redimensionamiento pueden tardar más. Esto reducirá el rendimiento.

La palabra clave new

En C++, podemos crear un array dinámico usando la palabra clave new. El número de elementos a asignar se especifica entre corchetes. El nombre del tipo debe preceder a esto. Se asignará el número solicitado de elementos.

Sintaxis:

La palabra clave new toma la siguiente sintaxis:

variable_puntero = new tipo_dato[tamaño];

La variable_puntero es el nombre de la variable puntero.

El tipo_dato debe ser un tipo de dato válido en C++.

La palabra clave devuelve un puntero al primer elemento. Tras crear el array dinámico, podemos eliminarlo usando la palabra clave delete.

Ejemplo 1:

#include<iostream>
using namespace std;
int main() {
    int x, n;
    cout << "Ingrese el número de elementos:" << "\n";
    cin >> n;
    int *arr = new int[n];
    cout << "Ingrese " << n << " elementos" << endl;
    for (x = 0; x < n; x++) {
        cin >> arr[x];
    }
    cout << "Usted ingresó: ";
    for (x = 0; x < n; x++) {
        cout << arr[x] << " ";
    }
    return 0;
} 

Salida:

Captura del código:

Explicación del código:

1. Incluya la cabecera iostream para usar sus funciones.
2. Incluya el espacio de nombres std para usar sus clases sin calificarlas.
3. Llame a la función main(). La lógica del programa debe añadirse dentro del cuerpo.
4. Declare dos variables enteras x y n.
5. Imprima texto en consola pidiendo al usuario el valor de n.
6. Lea la entrada del usuario y asígnela a n.
7. Declare un array para almacenar n enteros y asígnelo a la variable puntero *arr.
8. Imprima mensaje pidiendo al usuario ingresar n elementos.
9. Use un bucle for para iterar sobre los elementos ingresados.
10. Lea los elementos ingresados y almacénelos en el array arr.
11. Fin del cuerpo del bucle for.
12. Imprima texto en consola.
13. Use un bucle for para iterar sobre los elementos del array.
14. Imprima los valores contenidos en el array arr.
15. Fin del cuerpo del bucle for.
16. El programa debe retornar un valor tras completarse exitosamente.
17. Fin del cuerpo de main().

NOTA: En el ejemplo anterior, el usuario puede especificar cualquier tamaño para el array durante la ejecución. Esto significa que el tamaño del array se determina en tiempo de ejecución.

Inicialización de arrays asignados dinámicamente

Es fácil inicializar un array dinámico a 0.

Sintaxis:

int *array{ new int[longitud]{} };

En la sintaxis anterior, longitud denota el número de elementos. Como necesitamos inicializar a 0, se deja vacío.

Podemos inicializar un array dinámico usando una lista de inicialización. Creemos un ejemplo que lo demuestre.

Ejemplo 2:

#include <iostream>
using namespace std;
int main(void) {
    int x;
    int *array{ new int[5]{ 10, 7, 15, 3, 11 } };
    cout << "Elementos del array: " << endl;
    for (x = 0; x < 5; x++) {
        cout << array[x] << endl;
    }
    return 0;
} 

Salida:

Captura del código:

Explicación del código:

1. Incluya iostream para usar sus funciones.
2. Incluya espacio de nombres std.
3. Llame a main(). La lógica del programa va en su cuerpo.
4. Declare variable entera x.
5. Declare array dinámico llamado array usando lista de inicialización. Tendrá 5 enteros. Note que no usamos "=" entre la longitud y la lista.
6. Imprima texto en consola. endl mueve el cursor a la siguiente línea.
7. Use bucle for para iterar sobre elementos del array.
8. Imprima contenidos del array en consola.
9. Fin del cuerpo del bucle for.
10. El programa debe retornar valor al completarse exitosamente.
11. Fin del cuerpo de main().

Redimensionamiento de arrays

La longitud de un array dinámico se establece en el momento de la asignación.

Sin embargo, C++ no tiene un mecanismo integrado para redimensionar un array una vez asignado.

Puede superar esto asignando un nuevo array dinámicamente, copiando los elementos y luego eliminando el array antiguo.

Nota: esta técnica es propensa a errores, intente evitarla.

Eliminación dinámica de arrays

Un array dinámico debe eliminarse de la memoria una vez cumplido su propósito. La sentencia delete ayuda a lograr esto. La memoria liberada puede usarse para otro conjunto de datos. Incluso si no elimina el array, se eliminará automáticamente al terminar el programa.

Nota:

Para eliminar un array dinámico, debe usar delete[], no delete. Los corchetes indican a la CPU que elimine múltiples variables, no una sola. Usar delete en lugar de delete[] con un array dinámico puede causar problemas: fugas de memoria, corrupción de datos, bloqueos, etc.

Ejemplo 3:

#include<iostream>
using namespace std;
int main() {
    int x, n;
    cout << "¿Cuántos números escribirá?" << "\n";
    cin >> n;
    int *arr = new int[n];
    cout << "Ingrese " << n << " números" << endl;
    for (x = 0; x < n; x++) {
        cin >> arr[x];
    }
    cout << "Escribió: ";
    for (x = 0; x < n; x++) {
        cout << arr[x] << " ";
    }
    cout << endl;
    delete [] arr;
    return 0;
} 

Salida:

Captura del código:

Explicación del código:

1. Incluya iostream para usar sus funciones.
2. Incluya espacio de nombres std.
3. Llame a main(). La lógica va en su cuerpo.
4. Declare variables x y n de tipo entero.
5. Imprima texto pidiendo al usuario cuántos números ingresará.
6. Lea entrada del usuario y asígnela a n.
7. Declare variable puntero *arr. El array arr reservará memoria para n enteros.
8. Imprima mensaje pidiendo al usuario ingresar n números.
9. Cree bucle for con variable x para iterar sobre números ingresados.
10. Lea números ingresados y almacénelos en arr.
11. Fin del cuerpo del bucle for.
12. Imprima texto en consola.
13. Use bucle for para iterar sobre contenidos de arr.
14. Imprima valores del array arr.
15. Fin del cuerpo del bucle for.
16. Imprima línea vacía.
17. Libere memoria del array arr.
18. El programa retornará valor al completarse exitosamente.
19. Fin del cuerpo de main().

Resumen:

• Los arrays regulares tienen tamaño fijo. No puede modificarse tras la declaración.
• En estos arrays, el tamaño de memoria se determina en tiempo de compilación.
• Los arrays dinámicos son diferentes. Sus tamaños pueden cambiarse en tiempo de ejecución.
• En arrays dinámicos, el tamaño se determina en tiempo de ejecución.
• Los arrays dinámicos en C++ se declaran con la palabra clave new.
• Usamos corchetes para especificar el número de elementos a almacenar.
• Una vez terminado con el array, podemos liberar memoria con delete.
• Use delete[] para liberar memoria de todos los elementos del array.
• Un delete sin [] libera memoria de un solo elemento.
• No hay mecanismo integrado para redimensionar arrays en C++.
• Para inicializar un array con lista de inicialización, no use el operador "=".