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

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

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;