Free Web Site - Free Web Space and Site Hosting - Web Hosting - Internet Store and Ecommerce Solution Provider - High Speed Internet
Search the Web

Memoria dinámica

.- Reservar y liberar memoria para tipos de datos simples (int,double,void..)

Sintaxis :

tipo *identificador = (tipo *) malloc(sizeof(tipo))

Ejemplo

int *ptr = (int *) malloc(sizeof(int));

double *f = (double *) malloc(sizeof(double)); 

void *malloc(size_t size) 

Ya que ésta función retorna una dirección "sin tipo" o void , podemos hacer la conversión, anteponiendo (tipo *) a la función malloc.

Ejemplo

#include<stdio.h>
#include<stdlib.h>

int main()
{
   int *ptr = NULL;
   ptr = malloc(sizeof(int));    /*   origen del error  */
   *ptr = 4;
   printf("\n Dir : %p , valor : %d ",ptr,*ptr);
   free(ptr);
   return 0;
}

Al compilar este programa, arrojará el error :

Cannot convert 'void *' to 'int *'

ya que no se hizo la conversión necesaria.

Algo que es muy válido hacer, es implementar una función que haga lo mismo.
Por ejemplo :

int *reserv_mem(void)
{
   int *temp = NULL;
   temp = (int *) malloc(sizeof(int));
   return temp;
}

Por lo tanto una llamada a la función sería :

int *ptr = reserv_mem();

Para liberar memoria,simplemente se llama a la función free.

Ejemplo : free(ptr);

Programa de ejemplo

#include<stdio.h>
#include<stdlib.h>

int *reserv_mem(void);

int main()
{
   int *ptr = reserv_mem();
   printf("\n Reserva de memoria en direccion %p ",ptr);
   printf("\n Ingrese valor : ");
   scanf("%d",ptr);
   printf("\n Valor ingresado : %d",*ptr);
   free(ptr);
   return 0;
}

int *reserv_mem(void)
{
   int *temp = NULL;
   temp = (int *) malloc(sizeof(int));
   return temp;
}

.- Reservar y liberar memoria para tipos de datos estructurados

Ejemplo

typedef struct
{
   int a;
   double f;
   char c;
} T_EST,*EST;

En el caso de declaración de T_EST que no es puntero, la sintaxis es la misma que para datos simples.

T_EST *e = (T_EST *) malloc(sizeof(T_EST));

En cambio cuando se declara un tipo de dato puntero a estructura, la sintaxis cambia a lo siguiente :

EST ptr = (EST) malloc(sizeof(T_EST));

Ejemplo de acceso a los campos de las variables e y ptr :

e->a = 5;
e->f = 4.56;
e->c = 'a';
ptr->a = 7;
ptr->f = 2.78;
ptr->c = 'b';

Al igual que para variables simples, se puede implementar una función de reserva de memoria.

EST reserv_mem()
{
   EST temp = NULL;
   temp = (EST) malloc(sizeof(T_EST));
   return temp;
}

Para liberar memoria a una estructura de este tipo (campos simples), se usa la función free().
Al aplicar esta función, la memoria reservada para los campos se libera automáticamente.

Ejemplo

#include<stdio.h>
#include<stdlib.h>

typedef struct
{
  int a;
  double f;
  char c;
} T_EST,*EST;

EST reserv_mem(void)
{
   EST temp = NULL;
   temp = (EST) malloc(sizeof(T_EST));
   return temp;
}

int main()
{
  EST t = reserv_mem();
  
  printf("\n Dir t : %p",t);    
  
  /*  salida :  Dir t : 00780EA0  */

  t->a = 5;
  t->f = 3.5;
  t->c = 'a';

  printf("\n t->a = %d  , t->f = %.1f  , t->c = %c ",t->a,t->f,t->c);

  /* salida :  t->a = 5  ,  t->f = 3.5   , t-> c = a   */

  
/* Declaración de tres punteros para guardar 
las direcciones de los campos  */

  int *ptr = &(t->a);
  double *ptr2 = &(t->f);
  char *ptr3 = &(t->c);

  printf("\n\n DIRECCIONES DE MEMORIA DE LOS CAMPOS ");
  printf("\n t->a : %p \n t->f : %p \n t->c : %p",ptr,ptr2,ptr3);

/*  Salida :
    DIRECCIONES DE MEMORIA DE LOS CAMPOS
    t->a : 00780EA0
    t->f  : 00780EA8
    t->c :  00780EB0 
*/

/* Cambio de valores a través de indirección de punteros */

  *ptr = 10;    /*  t->a = 10; */
  *ptr2 = 7.0;    /*  t->f = 7.0; */
  *ptr3 = 'b';    /*  t->c = 'b'; */

/*
 
  *t = 10;         
  Aunque t = ptr = 00780EA0  --> no se permite conversión
  
*/

  printf("\n t->a = %d  , t->f = %.1f  , t->c = %c ",t->a,t->f,t->c);

/*  salida :  t->a = 10  ,  t->f = 7.0  , t->c = b   */

  free(t);

  printf("\n DESPUES DE LIBERAR LA VARIABLE : t");

  printf("\n Dir t : %p",t);   /*  salida :  Dir t : 00780EA0  */

  printf("\n t->a = %d  , t->f = %.1f  , t->c = %c ",t->a,t->f,t->c);

/*    salida :  t->a = "cualquier cosa" , ídem  t->f    y    t->c  */

  printf("\n t->a = %d  , t->f = %.1f  , t->c = %c ",*ptr,*ptr2,*ptr3);

/*  salida : " la misma salida anterior "     */

  return 0;

}

Nota : este programa fue compilado, en Visual C++ de Microsoft.