Este documento explica cómo asignar y liberar memoria dinámicamente en C++ usando punteros y los comandos new y delete. Se muestra cómo crear un arreglo dinámico de punteros a enteros y luego arreglos de enteros dentro de cada posición del arreglo de punteros. También se explica que es necesario liberar toda la memoria asignada usando delete para evitar problemas de memoria, mostrando cómo liberar primero cada subarreglo y luego el arreglo principal de punteros.

1. Punteros II
Ya dijimos que podiamos manejar la memoria a voluntad, pero no lo dejamos
muy claro con ejemplos, ahora veamos el manejo de memoria pidiendo y
liberando esta.
C tenia el comando malloc (memory allocate) y free, que pedian memoria y
liberaba respectivamente. C++ incluye los comandos new y delete que facilitan
mucho estos aspectos ejemplo:
//asumamos tenemos una estructura de datos llamada “Estructura”//
Estructura *nuevaEstructura;
nuevaEstructura=(Estructura)malloc(sizeof(Estructura));
Lo anterior lo que hace es pedirle al sistema operativo un espacio en memoria
que tenga el tamaño de “Estructura” y luego le hace un cast a ese sector para
que se “comporte” como un objeto Estructura.
Luego para liberar ese espacio:
Free(nuevaEstructura);
En cambio en C++ esto es mucho más sencillo, el mismo ejemplo anterior:
Estructura *nuevaEstructura;
nuevaEstructura=new Estructura;
El comando new simplifica las cosas en cuanto a problemas de espacio a asignar.
Ahora para liberar la memoria:
delete nuevaEstructura;
Veamos un ejemplo de cómo generar un arreglo de forma dinámica usando
punteros y los comandos new y delete

2. int **arreglo;
arreglo=new *int[10];
for (int i=0; i<=10;i++)
{
arreglo[i]=new int[10];
}
Lo anterior genera una matriz de (10+1)x(10+1) elementos de tipo entero.
Algo importantísimo que se debe tener en mente al estar trabajando con la
memoria de esta forma es que toda memoria pedida debe ser liberada, el
sistema operativo no ocupara el sector asignado si no le pedimos que lo libere,
así que cada vez que ya no se necesite la memoria almacenada es bueno
liberarla para, de esta forma, no hacer que la memoria ram se acabe.
Usando el mismo arreglo creado dinámicamente explicare como se libera:
for (int i=0; i<=10;i++)
{
delete [] arreglo[i] ;
}
delete [] arreglo;
Al crear dinámicamente una matriz lo que hicimos fue crear un arreglo de
punteros de tipo entero, y en cada casilla de ese arreglo creamos un arreglo de
largo 10:
*0
*1
*2
.
.
.
.
*10

3. Luego cada uno de esos punteros de transformo en un arreglo de enteros de
tamaño 10.
Entonces para poder liberar esa memoria debemos liberar la memoria indexada
por cada uno de esos punteros por eso esta el lazo iterativo:
for (int i=0; i<=10;i++)
{
delete [] arreglo[i] ;
}
que lo que hace es ir liberando la memoria indexada de cada casilla del arreglo,
luego de eso la sentencia:
delete [] arreglo;
libera la memoria almacenada en el arreglo de punteros, dejando la memoria
liberada, lista para ser pedida por nosotros u otro programa corriendo en el
background de nuestro entorno de trabajo.
Nota:
delete [] arreglo; indica libere la memoria que tiene estructura de arreglo
Después de todo ese jugo les puedo decir que también se puede crear un
arreglo de forma dinámica mucho mas simple, pero si no hubiese dado ese
ejemplo no hubiese sido tan explicativo no?, (aunque quizás se enredaron mas
aun, a mí me paso la primera vez que vi ese ejemplo).
Int * arreglo;
arreglo=new int[10][10];
Lero 2005;