Introduction au langage C/Allocation dynamique de mémoire

Début de la boite de navigation du chapitre

fin de la boite de navigation du chapitre

Les tableaux en C permettent de ranger des informations et de s'y référer par un numéro, l'index. Dans l'utilisation la plus simple de ces tableaux, on fixe les limites du tableau en écrivant le code. La gestion de la mémoire se fait alors de manière automatique. On peut en revanche décider ou avoir besoin de gérer soi-même la taille du tableau alors que le programme est en cours d'exécution. Faire cela s'appelle « allouer dynamiquement » de la mémoire au programme.

Introduction

On utilise beaucoup plus souvent l'allocation automatique (où c'est le programme qui ce charge de tout) que l'allocation dynamique, mais cela s'avère parfois être l'unique solution.

Un exemple d'allocation automatique serait la déclaration d'une variable, le programme alloue de la mémoire à la déclaration de la variable et à la fin du bloc la variable est automatiquement supprimé par le programme. Ceci est très pratique pour les types de bases mais lorsque il peut être intéressant d'utiliser l'allocation dynamique pour créer des tableaux d'une taille indéfinie lors de l'exécution du programme.

Un exemple d'utilisation de l'allocation dynamique : vous souhaitez que l'utilisateur entre une série de chiffre, mais ne savez pas combien d'élément comportera cette série. Vous pourriez préparer un certain nombre de place n, et occuper uniquement celles qui vous servent — mais cela vous limiterait à n entrées, et utiliserait de toute manière la place mémoire pour n données. L'allocation dynamique de mémoire vous permet de redéfinir la taille du tableau en cours d'exécution, d'ajouter ou supprimer des entrées, sans limites ou presque.

Taille des variables

Toutes les types de variables occupent une certaines place en mémoire, qui s'exprime en octets. Selon que vous créez une variable de type short ou de type int vous avez ainsi besoin de plus ou moins de mémoire. De plus, selon le système considéré, un même type peut occuper une place différente.

Pour connaitre la place que prend en mémoire un certain système il suffit d'utiliser l'opérateur sizeof.

Par exemple pour connaitre la taille d'un int sur le système il vous suffit de faire:

sizeof(int);

Attention : sizeof() n'est pas une fonction, c'est un opérateur. C'est pour cela que cette instruction sera remplacée à la compilation par la taille du type int par le compilateur. Si vous compilez sur un système, c'est la valeur pour ce système qui sera enregistrée, quelle que soit la machine sur laquelle vous exécuterez le programme.

Si vous voulez afficher la taille que prend en mémoire les types de bases, il vous suffit de faire :

printf("char : %ld octetsn", sizeof(char));
printf("int : %ld octetsn", sizeof(int));
printf("long : %ld octetsn", sizeof(long));
printf("double : %ld octetsn", sizeof(double));

Allocation dynamique

L'allocation dynamique se fait par le biais de la fonction malloc() qui permet d'allouer un certain nombre d'octets et qui renvoie un pointeur sur cette case mémoire allouée. Voici le prototype de la fonction malloc() :

void * malloc (size_t size);

Le type void est un passe-partout, il permet de remplacer n'importe quel autre type.

Ainsi pour allouer dynamiquement un int il suffit de faire :

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

Vérifier que l'allocation a été un succès

Pour vérifier que l'allocation a été un succès, il suffit de tester le pointeur. Si celui ci vaut NULL alors l'allocation a échoué sinon l'allocation a réussi.

int *p = malloc(sizeof(int));
if(p == NULL)
{
    perror("Echec allocation memoire");
    exit(1);
}

Libération de la mémoire

Pour libérer la mémoire c'est tout aussi facile. La fonction qui permet de libérer de la mémoire est free(), elle attend comme unique paramètre le pointeur sur la case mémoire à libérer.

free(p);

N'oubliez pas de libérer la mémoire à la fin de votre programme, sans quoi il y aura des « fuites » — des cases mémoires inutilisées mais bloquées par l'allocation.

Allocation dynamique d'un tableau

Quelle taille prend un tableau de 5 int ? Réponse : 5 * sizeof(int).

Ainsi, pour créer un tableau de 5 int il suffit de faire :

int *tab = malloc(5 * sizeof(int));

Comment faire un tableau de taille variable ? Vous pourriez penser écrire :

int tab[var];

Et bien, non. Ceci est en effet interdit en C, il faut faire une allocation dynamique comme vu précédemment. De façon plus générale pour faire un tableau de taille variable, il faut faire comme suit :

int *tab= malloc(var * sizeof(int));

Encore une fois n'oubliez pas de libérer la mémoire à la fin du programme. Une autre fonction existe pour créer des tableaux dynamiquement, son prototype est:

void * calloc (size_t nmemb, size_t size);

Pour créer un tableau de taille variable vous devez faire :

int *tab = calloc(var, sizeof(int));