Alocación dinámica de memoria

Un puntero es una variable que toma como valor la dirección de memoria en donde hay algo almacenado. Un error común en el uso de punteros es su utilización antes de haberles asignado un lugar válido donde apuntar. Esto se hace o bien heciendo que apunten a una variable ya definida, o asignandole en "run-time" un lugar válido a donde apuntar. Esto último se realiza con lo que se denomina alocación dinámica de memoria, esto es reservar espacio en la memoria para almacenar datos de un tipo dado, y hacer la referencia a esos datos a través de punteros.

El lenguaje C posee, en sus bibliotecas estándar, funciones para realizar alocación dinámica de memoria.

Una de las funciones que realiza ésto es la función "malloc", cuya utilización es la siguiente:

void *malloc(int size);

Esta función aloja size bytes y retorna un puntero al primer byte, para hacer la asignación a algún puntero. Si la función por algun motivo, es incapaz de alojar el espacio requerido, returna NULL (0).

Existe además una función inversa, cuyo efecto es liberar la memoria a la que apunta un puntero, para poder ser utilizada nuevamente. Esta función es free(void *ptr);

Ejemplos:





	
	ejem_alloc.c


#include <stdlib.h>
#include <stdio.h>
int main()
{
  int *Ptr;
  int i;

  Ptr = (int *) malloc(10 * sizeof(int));  /* reserva de 10 int */
  if(Ptr == NULL)
    perror("ERROR");
  else
  {
    for(i = 0; i < 10;i++)
      Ptr[i] = i;

    for(i = 0; i < 10; i++)
      printf("%d\n",Ptr[i]);
    free(Ptr);      /* Libera la mem. apuntada por Ptr  */
  }
  return 0;
}

/* Alocación dinámica de memoria para utilizar una
   matriz como un arreglo de punteros                 */
#include <stdio.h>
#include <stdlib.h>

double **AllocMat(int nFilas, int nColumnas);
void CargaMat(double **M, int nFilas, int nColumnas);
void ImprimeMat(double **M, int nFilas, int nColumnas);
void LiberaMat(double **M, int nFilas);

int main()
{
  double **Matriz;
  int i, j;

  Matriz = AllocMat(10,50);
  CargaMat(Matriz, 10, 50);
  ImprimeMat(Matriz, 10, 50);
  LiberaMat(Matriz, 10);
  return 0;
}

/* Función: AllocMat
 * Argumentos: Dimensiones de la matriz a alojar
 * Descripción: Aloja una matriz como un arreglo de
 *   punteros a double.
 * Retorno: Devuelve un puntero a la matriz alojada o
 *   NULL si ocurrio algun error.
 */
double **AllocMat(int nFilas, int nColumnas)
{
  double **Mat;
  int i;

  if((Mat = (double**) malloc(nFilas * sizeof(double *))) == NULL)
    return NULL;

  for(i=0; i<nFilas; i++)
    if((Mat[i] = (double *) malloc(nColumnas * sizeof(double)))==NULL)
    {
      LiberaMat(Mat,i);
      return NULL;
    }
  return Mat;
}
/* ... */
/* ... */