Introducción a Memoria dinámica en C

Cuando entras en el mundillo de la programación C a mucha gente le pasa que se atraganta cuando llega a lo que serían los punteros y memoria dinámica. Es algo normal, a la mayoría de la gente le pasa y por eso os traigo este pequeño tutorial sobre memoria dinámica en C.

Generalmente, cuando queramos crear un array dinámico en C, primero debemos declarar el puntero del tipo que queramos el array, en este caso, lo llamaremos P.

#include <stdio.h>
#include <stdlib.h>
int *P;

int main(){

}

Malloc()

Una vez hecho esto, debemos reservar la memoria que necesitaremos para almacenar elementos en este array dinámico, en este caso, por ejemplo, queremos crear un array dinámico que pueda contener 100 elementos. Para ello utilizaremos Malloc, que lo que hace es reservar la memoria y devolver un puntero a la dirección donde esté la memoria reservada, en este caso lo utilizaríamos de la siguiente manera:

#include <stdio.h>
#include <stdlib.h>
int *P;

int main(){
P = (int *) malloc(100 * sizeof(int));
//Malloc(tamaño*sizeof(Tipo_de_Dato))
}

el (int *) que hemos puesto delante del malloc es para evitar ciertos problemas que se podrían tener en sistemas unix si se hiciera el Malloc a palo seco. Dentro del malloc hemos puesto 100*sizeof(int) para que reserve el tamaño equivalente a 100 elementos de tipo entero, sizeof(int) nos daría el tamaño de un elemento de tipo int, por eso lo utilizamos, si quisiéramos hacer un array dinámico que no fuera de tipo entero, cambiaríamos el int por el tipo que vayamos a utilizar.

Free()

Cuando terminemos con el array dinámico debemos liberar la memoria usando Free(). Un ejemplo de uso para este caso sería el siguiente:

#include <stdio.h>
#include <stdlib.h>
int *P;

int main(){
P = (int *) malloc(100 * sizeof(int));
free(P);
}

Calloc()

En caso de que quisiéramos hacer un array dinámico en el que todas sus posiciones estuvieran inicializadas a NULL, utilizaríamos calloc(). A continuación dejo un ejemplo de como se utilizaría para un array dinámico de 100 posiciones:

#include <stdio.h>
#include <stdlib.h>
int *P;

int main(){
   P = (int *) calloc(100, sizeof(int));
   //calloc(tamaño, sizeof(Tipo_de_Dato))
   free(P);
}

Realloc()

Si quisiéramos ampliar el tamaño del array dinámico que hemos creado, utilizaríamos realloc(). Por ejemplo, si queremos ampliar nuestro array dinámico de 100 posiciones a 150 posiciones utilizaríamos realloc() de la siguiente manera:

#include <stdio.h>
#include <stdlib.h>
int *P;

int main(){
   P = (int *) malloc(100 * sizeof(int));
   P = (int *) realloc(P, 50*sizeof(int));
   //realloc(puntero, ramaño*sizeof(Tipo_de_Dato))
   free(P);
}

Lo que haremos será meter dentro del realoc() primero el array dinámico que queremos ampliar y después el tamaño que le queramos añadir, como en este caso el tamaño de nuestro array era de 100 y lo queremos ampliar a 150 tendríamos que indicar que queremos 50 veces el tamaño de int (50*sizeof(int))