Memoria dinmica

Hasta ahora, hemos realizado una administracin de memoria de tipo esttico. Esto significa que los vectores y matrices creados tienen un tamao fijo que el compilador conoce en tiempo de compilacin. Sin embargo, es posible que el tamao de dichos vectores no se conozca a-priori y por lo tanto necesitemos solicitar memoria al sistema en tiempo de ejecucin. La administracin de memoria desde este punto de vista recibe el nombre de memoria dinmica.

El tratamiento de memoria dinmica sigue tres pasos fundamentales: 1) Peticin de memoria (funcin malloc) 2) Utilizacin de dicha memoria para nuestro propsito 3) Liberacin de memoria (funcin free) La funcin malloc posee la siguiente sintaxis: [ [direcc_inicio] malloc([tamao en bytes]);

Para especificar la cantidad de memoria que necesitamos se suele utilizar la funcin sizeof. [tamao en bytes] sizeof( [tipo definido] );

Combinando estas funciones podremos reservar memoria para vectores, matrices, etc Para liberar memoria asignada utilizaremos la funcin free, especificando la direccin de inicio de la misma. Su sintaxis es la siguiente: free( [direcc_inicio] );

A partir de esta instruccin, la memoria que habamos reservado podr ser utilizada por otros procesos del sistema.

a) Vectores dinmicos
/*Veamos un ejemplo en el que solicitamos al usuario una cierta cantidad de nmeros para despus mostrarlos por pantalla en el mismo orden en el que se introdujeron. Al principio del programa solicitaremos al usuario cuntos nmeros desea introducir:*/ #include <stdio.h> void main(void){ int *vector; /*creo el vector a entero*/ int n, i; printf ("Elementos a introducir:"); scanf ("%d",&n); vector = malloc( sizeof(int)*n); /* peticion de memoria*/ for ( i= 0; i < n ; i++){ printf ("Elemento %d:", i); scanf ( "%d", &(vector[i]) ); } for ( i=0; i < n; i++){ printf("Elemento %d = %d\n",i,vector[i]); } free(vector); /*liberacin*/ return; } vector

b) Matrices dinmicas
El problema del tratamiento de matrices dinmicas es similar al del tratamiento de vectores, teniendo en cuenta que una matriz es un vector de vectores.

int Matriz[3][6];
Matriz Matriz[0] Matriz[1] Matriz[2]

#include <stdio.h> void main(void){ int **Matriz; /*Puntero de puntero*/ int nfil, ncol, i, j; printf ("Filas:"); scanf ( "%d", &nfil); printf ("Columnas:"); scanf("%d",&ncol); matriz = malloc (sizeof (int*)*nfil); /*reserva de memoria punteros*/

for( i= 0; i < nfil; i++){ matriz[i] = malloc ( sizeof (int) *ncol); /*reserva de memoria matriz*/ } for ( i=0; i < nfil; i++){ /*Preguntamos los valores*/ for( j = 0; j < ncol; j++){ printf ("Elemento (%d,%d):", i, j); scanf ("%d", &(Matriz[i][j])); } } for ( i=0; i< nfil; i++){ /*Imprimimos los valores */ for( j = 0; j < ncol; j++){ printf ("Elemento (%d,%d) = %d\n", i, j, Matriz[i][j]); } } for ( i=0; i< nfil; i++){ /*liberamos la memoria*/ free(Matriz[i]); } free(Matriz); return; }

c. Estructuras dinmicas de datos

En funcin de la forma en que se relacionan existen varios tipos de estructuras de datos. Este tipo de estructuras son autorreferenciadas, es decir, contienen entre sus campos un puntero de su mismo tipo. Las ms utilizadas son: pilas colas listas

Las pilas
Este tipo de estructuras se caracteriza porque todas las operaciones se realizan en el mismo lado. Es de tipo LIFO ( Last In First Out ), el ltimo elemento en entrar es el primero en salir. /* Ejemplo de una pila. */ #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <alloc.h> void insertar(void); void extraer(void); void visualizar(void); struct pila { char nombre[20]; struct pila *ant; }*CAB=NULL,*AUX=NULL; main() /* Rellenar, extraer y visualizar */ { char opc; do { clrscr(); /* borramos la pantalla */ gotoxy(30,8); /* columna 30, fila 8 */ printf("1.- Insertar"); gotoxy(30,10); printf("2.- Extraer"); gotoxy(30,12); printf("3.- Visualizar la pila"); gotoxy(30,14); printf("4.- Salir"); opc=getch( ); switch(opc)

{ case '1': insertar( ); break; case '2': extraer( ); break; case '3': visualizar( ); } }while (opc!='4'); } void insertar(void) { AUX=(struct pila *)malloc(sizeof(struct pila)); clrscr(); printf("Nombre: "); gets(AUX->nombre); if (CAB==NULL) { CAB=AUX; AUX->ant=NULL; } else { AUX->ant=CAB; CAB=AUX; } } void extraer(void) { if (CAB==NULL) return; AUX=CAB; CAB=CAB->ant; free(AUX); } void visualizar(void) { if (CAB==NULL) return; clrscr(); AUX=CAB; while (AUX!=NULL) { printf("Nombre: %s\n",AUX->nombre); AUX=AUX->ant; } getch( );

} La estructura tipo que utilizaremos ser sta: struct pila { tipo variables; struct pila *ant; }*CAB=NULL,*AUX=NULL; donde tipo variables sern las diferentes variables que guardaremos en la estructura, struct pila *ant es un puntero que apunta al elemento de tipo pila introducido anteriormente, *CAB ser donde guardaremos el ltimo elemento insertado en la pila y *AUX nos servir para guardar elementos temporalmente y para recorrer la pila al visualizarla. Antes de insertar un elemento, deberemos comprobar si la pila est vaca o no. Si lo estuviera deberemos insertar el primer elemento: CAB=AUX; CAB->ant=NULL; Si ya hubiera algn elemento crearemos uno nuevo apuntado por AUX y haremos que AUX->ant apunte a CAB, que en este momento contiene la direccin del elemento insertado anteriormente. Tras esto haremos que CAB apunte al ltimo elemento insertado, que ser la nueva cabeza de la pila: AUX->ant=CAB; CAB=AUX; Para extraer un elemento de la pila deberemos hacer que AUX apunte a la misma direccin que CAB, despus haremos que CAB apunte a CAB->ant, con lo que el elemento anterior pasar a ser la cabeza de la pila. Tras esto, solo queda liberar la memoria de la zona apuntada por AUX. No olvides controlar si existe algn elemento ( si CAB es igual a NULL la pila est vaca ): if (CAB==NULL) return; AUX=CAB; CAB=CAB->ant; free(AUX); Por ltimo, para visualizar los elementos de la pila, haremos que el puntero auxiliar AUX apunte a la cabeza de la pila, o sea, a CAB. Tras esto iremos visualizando el contenido de la pila, haciendo que AUX tome la direccin de AUX->ant, mientras AUX sea distinto de NULL. Tambin es importante controlar que la pila no est vaca. if (CAB==NULL) return;

AUX=CAB; while (AUX!=NULL) { printf("%s",AUX->nombre); AUX=AUX->ant; }; Estructura grfica de una pila:

Las colas
Este tipo de estructuras se caracteriza porque insertamos los elementos por un lado y los extraemos por el otro lado. Es de tipo FIFO ( First In First Out ), el primer elemento en entrar es el primero en salir. Para gestionar la cola utilizaremos 3 punteros ( para la pila solo eran necesarios 2 ). /* Ejemplo de una cola. */ #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <alloc.h> void insertar(void); void extraer(void); void visualizar(void); struct cola { char nombre[20]; struct cola *sig; }*CAB=NULL,*AUX=NULL,*FIN=NULL; main() /* Rellenar, extraer y visualizar */ { char opc;

do { clrscr(); gotoxy(30,8); printf("1.- Insertar"); gotoxy(30,10); printf("2.- Extraer"); gotoxy(30,12); printf("3.- Visualizar la cola"); gotoxy(30,14); printf("4.- Salir"); opc=getch( ); switch(opc) { case '1': insertar( ); break; case '2': extraer( ); break; case '3': visualizar( ); } }while (opc!='4'); } void insertar(void) { AUX=(struct cola *)malloc(sizeof(struct cola)); clrscr(); printf("Nombre: "); gets(AUX->nombre); AUX->sig=NULL; if (FIN==NULL) FIN=CAB=AUX; else { FIN->sig=AUX; FIN=AUX; } } void extraer(void) { if (CAB==NULL) return; AUX=CAB; CAB=CAB->sig; free(AUX); }

void visualizar(void) { if (CAB==NULL) return; clrscr(); AUX=CAB; while (AUX!=NULL) { printf("Nombre: %s\n",AUX->nombre); AUX=AUX->sig; } getch(); } La estructura que utilizaremos ser: struct cola { tipo variables; struct cola *sig; }*CAB=NULL,*AUX=NULL,*FIN=NULL; donde tipo variables sern las diferentes variables que guardaremos en la estructura, struct cola *sig es un puntero que apunta al elemento de tipo cola introducido a continuacin, *CAB ser donde guardaremos el primer elemento insertado en la cola, *AUX nos servir para guardar elementos temporalmente y para recorrer la cola al visualizarla y *FIN tomar la direccin del ltimo elemento insertado. Antes de insertar un elemento, deberemos comprobar si la cola est vaca o no. Si lo est deberemos insertar el primer elemento: if (FIN==NULL) CAB=FIN=AUX; Si ya existiera algn elemento haremos que FIN->sig apunte al elemento de AUX y a continuacin haremos que FIN tome la direccin de AUX, con lo que FIN apuntar al ltimo elemento insertado. FIN->sig=AUX; FIN=AUX; Para extraer un elemento de la cola haremos que el puntero auxiliar AUX tome la direccin del primer elemento insertado, que hemos guardado en CAB. Tras esto haremos que CAB apunte a CAB->sig, es decir, que tome la direccin del segundo elemento insertado, que ahora pasar a ser el primero. Luego liberaremos la zona de memoria apuntada por AUX:

AUX=CAB; /* Deberemos controlar que no est vaca: if (CAB==NULL) return; */ CAB=CAB->sig; free(AUX); Para visualizar la cola comprobaremos que existan elementos, esto es, que FIN sea distinto de NULL. Hecho esto asignaremos a AUX la direccin de CAB e iremos recorriendo la cola hasta que AUX sea igual a NULL. AUX=CAB; /* Deberemos controlar que no est vaca: if (CAB==NULL) return; */ while(AUX!=NULL) { printf("%s",AUX->nombre); AUX=AUX->sig; } Estructura grfica de una cola:

Las listas Este tipo de estructuras se caracteriza porque los elementos estn enlazados entre s, de manera que adems de las acciones habituales de insertar, extraer y visualizar tambin podremos buscar un elemento. Para gestionar la lista utilizaremos 4 punteros. /* Ejemplo de una lista. */ #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <alloc.h> void insertar(void); void extraer(void); void visualizar(void);

struct lista { int num; struct lista *sig; }*CAB=NULL,*AUX=NULL,*F=NULL,*P=NULL; main() /* Rellenar, extraer y visualizar */ { char opc; do { clrscr( ); gotoxy(30,8); printf("1.- Insertar"); gotoxy(30,10); printf("2.- Extraer"); gotoxy(30,12); printf("3.- Visualizar la lista"); gotoxy(30,14); printf("4.- Salir"); opc=getch( ); switch(opc) { case '1': insertar( ); break; case '2': extraer( ); break; case '3': visualizar( ); } }while (opc!='4'); } /* A continuacin insertaremos el elemento que vamos a crear en la posicin que le corresponda, teniendo en cuenta que la lista deber quedar ordenada de menor a mayor. El puntero P comprueba si el campo num de un elemento es menor que el campo num del elemento introducido. El puntero F se quedar apuntando al elemento de la posicin anterior al elemento que hemos insertado */ void insertar(void) { AUX=(struct lista *)malloc(sizeof(struct lista)); clrscr( ); printf("Introduce un nmero: "); scanf("%d",&AUX->num);

AUX->sig=NULL; if (CAB==NULL) CAB=AUX; else if (CAB->num > AUX->num) { AUX->sig=CAB; CAB=AUX; } else { P=F=CAB; while (P->num < AUX->num && P!=NULL) { if (P==CAB) P=P->sig; else { P=P->sig; F=F->sig; } } AUX->sig=F->sig; F->sig=AUX; } } void extraer(void) { int var; if (CAB==NULL) return; clrscr( ); printf("Introduce el nmero a extraer: "); scanf("%d",&var); if (CAB->num==var) { P=CAB; CAB=CAB->sig; free(P); } else { P=F=CAB; while (P->num != var && P!=NULL) { if (P==CAB) P=P->sig; else { P=P->sig; F=F->sig; } }

if (P==NULL) return; F->sig=P->sig; free(P); } } void visualizar(void) { if (CAB==NULL) return; clrscr( ); AUX=CAB; while (AUX!=NULL) { printf("Nmero: %d\n",AUX->num); AUX=AUX->sig; } getch( ); } La estructura que utilizaremos ser: struct lista { tipo variables; struct lista *sig; }*CAB=NULL,*AUX=NULL,*F=NULL,*P=NULL; donde tipo variables sern las variables que guardaremos en la estructura, struct lista *sig es un puntero que apunta al elemento de tipo lista introducido a continuacin, *CAB ser donde guardaremos el primer elemento de la lista, *AUX nos servir para guardar elementos temporalmente y para recorrer la lista al visualizarla, *P para comparar los valores introducidos y ordenarlos, y *F, que apuntar al elemento anterior al ltimo introducido. Antes de insertar un elemento, deberemos comprobar si la lista est vaca o no. Si lo est deberemos insertar el primer elemento: if (CAB==NULL) CAB=AUX; Si ya existiera algn elemento haremos que P y F apunten al primero de la lista. Si el elemento introducido fuera menor que el primero de la lista, haramos que el nuevo elemento pasara a ser el primero, y el que hasta ahora era el primero, pasara a ser el segundo. if (AUX->num < CAB->num){ AUX->sig=CAB; CAB=AUX; }

Para extraer un elemento de la lista solicitaremos un nmero, si el nmero introducido se corresponde con el campo num de uno de los elementos, ste ser extrado de la lista. Deberemos controlar que la lista no est vaca y que el elemento con el nmero solicitado exista. Fjate en el ejemplo, en la funcin extraer. Si CAB es igual a NULL, ser que la lista est vaca, y si P es igual a NULL al salir del while significar que no se ha encontrado ningn elemento que contenga el nmero introducido. Para visualizar la lista comprobaremos que existan elementos, es decir, que CAB sea distinto de NULL. Hecho esto asignaremos a AUX la direccin de CAB e iremos recorriendo la lista mientras AUX sea distinto de NULL. if (CAB==NULL) return; AUX=CAB; while(AUX!=NULL) { printf("%d",AUX->num); AUX=AUX->sig; } Estructura grfica de una lista:

Aqu finaliza el tema de la gestin dinmica de memoria. Es un tema algo complejo hasta que se asimila el concepto y funcionamiento de las diferentes estructuras, pero tras conseguirlo ya no tiene ningn secreto. Si alguna vez no recuerdas su funcionamiento siempre es una buena solucin coger papel y lpiz, dibujar una pila, cola o lista grficamente y simular la introduccin de elementos, escribiendo la situacin de los punteros en cada momento. Existen otras estructuras, como las listas circulares y las listas doblemente enlazadas. La nica diferencia con la lista que conocemos es que en las primeras el

puntero final enlaza al nodo inicial y con la segunda que cada elemento guarda la direccin del nodo anterior y del posterior, dando una estructura del tipo: struct lista_doble { char nombre[20]; struct lista_doble *ant; struct lista_doble *sig; }; Su funcionamiento es muy similar al de una lista normal. Otras estructuras, como los rboles son ms complejas y menos utilizadas.