Description des mécanismes d'allocation dynamique de mémoire en langage C

La fonction malloc() a la signature suivante :

void * malloc ( size_t t )

Cette fonction demande au système d'exploitation un bloc de taille t (en bytes) et renvoie un pointeur vers l'adresse du bloc alloué. S'il se produit une erreur, typiquement il n'y a plus de mémoire disponible, cette fonction renvoie la valeur NULL. La fonction retourne une adresse non typée, ceci n'est pas un problème, en effet, le type void * est compatible avec tous les pointeurs, par conséquent une conversion de type n'est pas obligatoire. Cependant, pour des raisons historiques, il était d'usage d'effectuer cette conversion sur le retour de la fonction dans le type de la variable qui stockera cette adresse. Ainsi, si on voulait allouer dynamiquement un entier, on faisait une conversion de type vers un pointeur d'entier. Ceci n'est cependant plus une chose à faire et nous nous efforcerons de ne plus le faire. Voici ce que cela peut donner pour un entier :

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

Expliquons quelque peu ce petit exemple : tout d'abord, nous définissons un pointeur sur un entier (ici un pointeur sur un int). C'est ce pointeur qui va nous permettre de contenir l'adresse de l'élément qui va être alloué. En généralisant on peut dire que pour allouer dynamiquement un objet de type T, il faudra créer un pointeur sur un type T. Ensuite, nous tentons d'allouer la mémoire via la fonction malloc. nous donnons en paramètre de cette fonction, l'argument suivant : sizeof(int). Ceci nous permet de connaître la taille en octet à allouer. En effet, comme nous l'avons dit plus tôt dans cet article, la fonction malloc() alloue un bloc de taille t et non pas un bloc d'un type donné, cela est dû au fait que le système d'exploitation ne sais réserver qu'un espace mémoire, il ne sais pas si ce bloc va contenir un entier ou une structure beaucoup plus complexe. il faut donc indiquer la taille du bloc que l'on veut allouer. Ici, il s'agit tout simplement de la taille du type entier (dans notre cas du type int ). Comme il n'est pas toujours possible de connaître la taille en octet des objets que nous voulons allouer. L'opérateur sizeof nous simplifie alors le travail. Celle ci nous donne la taille en bytes d'un type (ou d'une variable) donné. Ainsi, la fonction malloc() connaît désormais la taille de ce qui doit être alloué. Si tout se passe bien, p devrait contenir une adresse mémoire indiquant où se situe le bloc que le système d'exploitation vient d'allouer.

Cependant, nous avons oublié quelque chose. En effet, nous sommes parti du principe que tout avait fonctionné correctement. Nous n'avons pas testé la valeur de retour de la fonction malloc().C'est celle-ci qui va nous permettre de vérifier que ladite fonction s'est correctement éxécutée. Comme nous l'avons dit plus tôt, si la fonction renvoie NULL, c'est qu'elle n'a pas réussi à allouer la mémoire. Si la valeur de retour n'est pas NULL, alors tout c'est bien passé. En fait, si la valeur n'est pas NULL, c'est que la fonction a renvoyé une adresse mémoire et donc que l'allocation a été faite.

Voici donc le premier exemple correct :

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

if ( p == NULL )
{
     fprintf(stderr,"Allocation impossible \n");
     exit(EXIT_FAILURE);
}

Ainsi, maintenant, si l'allocation dynamique n'a pas pu avoir lieu, le programme affiche un message d'erreur et quitte en retournant la constante EXIT_FAILURE

Compliquons un petit peu notre exemple et créons une structure qui devra être allouée :

/* le type complexe */
struct complexe
{
     double Re;
     double Im;
};
/* une défition plus courte pour la structure */
typedef struct complexe Complexe;

Complexe * c;

c = malloc(sizeof(Complexe));

if ( c == NULL )
{
     fprintf(stderr,"Allocation Impossible");
     exit(EXIT_FAILURE);
}

L'exemple ne rajoute aucune difficulté, ici nous n'allouons pas un type atomique (entier, réel, caractère,...), mais une structure. Comme vous pouvez le constater, le schéma d'allocation est rigoureusement le même : on alloue un bloc de taille sizeof(struct complexe). Dans notre exemple, nous n'avons que deux membres dans notre structure mais le schéma serait le même si nous avions une structure beaucoup plus complexe.

1-1-1. Allocation dynamique de tableaux▲

Complexe * tab;

tab = malloc (3 * sizeof(Complexe));

if( tab == NULL )
{
     fprintf(stderr,"Allocation impossible");
     exit(EXIT_FAILURE);
}

/* La première case */
(*tab).Re = 10.;
(*tab).Im = 10.;

/* La deuxième case */
(*(tab + 1)).Re = 15.;
(*(tab+ 1)).Im = 20.;

/* La troisième */
(*(tab + 2)).Re = 1.;
(*(tab + 2)).Im = 1.;

/* La première case */
tab[0].Re = 10.;
tab[0].Im = 10.;

/* La deuxième case */
tab[1].Re = 15.;
tab[1].Im = 20.;

/* La troisième */
tab[2].Re = 1.;
tab[2].Im = 1.;

Revenons un peu sur l'allocation de notre tableau, comme nous l'avons vu précédemment, nous pouvons utiliser une autre fonction pour allouer de la mémoire : calloc(). Voici sa signature :

void * calloc (size_t n, size_t t)

La fonction alloue n blocs de taille t. elle est donc presque équivalente à l'appel suivant :

malloc( n * t );

La seule différence réside dans le contenu des cases qui sont allouée. En effet, avec malloc(), le contenu est totalement aléatoire tandis qu'avec calloc, les cases contiennent des valeurs nulles (tous les bits du bloc alloué sont mis à 0). Ceci est très utile pour initialiser rapidement un tableau de nombre. Si ce n'est ce point de détail, il n'y a aucune autre différence, et nous pourrons donc écrire notre code précédent de la façon suivante :

Complexe * p;

p = calloc (3 , sizeof(Complexe));

Pour des raisons de non redondance, nous ne remettons pas les tests de validité du pointeur, mais ils sont essentiels. Comme vous pouvez le constater, il n'y a aucune différence, en terme d'utilisation juste après le calloc.

Voyons un dernier exemple d'allocation dynamique avant de voir la réallocation. Notre dernier exemple d'allocation dynamique va nous permettre d'allouer un tableau à deux dimensions (mais le schéma serait le même quelque soit le nombre de dimensions). Cet exemple est tout simplement là pour vous montrer que l'on peut aussi allouer un espace mémoire pour des pointeurs, en effet, les pointeurs ne sont ni plus ni moins que des entiers (une adresse mémoire est identifée par un entier).

Voici donc comment on alloue un tableau de trois tableau de trois entier. En d'autres termes nous créons une matrice carrée d'entiers de taille 3 :

int **matrice , i;

matrice = malloc( 3 * sizeof(int*));

if( matrice == NULL )
{
     fprintf(stderr,"Allocation impossible");
     exit(EXIT_FAILURE);
}

for( i = 0 ; i < 3 ; i++ )
{
     matrice[i] = calloc (3, sizeof(int));
     
     if( matrice[i] == NULL )
     {
          fprintf(stderr,"Allocation impossible");
          exit(EXIT_FAILURE);
     }
}

/* remplissage */
for( i = 0 ; i<3 ; i++ )
     matrice[i][i] = 1;

Comme vous pouvez le constater, lors du remplissage, nous ne remplissons que la diagonale, la fonction calloc() ayant mis à 0 toutes les cases lors de l'allocation.

A propos de ceci il faut faire attention à une chose : ce n'est pas parce que la fonction calloc() met les bits du bloc mémoire alloué à 0 que la valeur de la variable alloué est forcément égale à 0. La norme n'impose en effet aucune chose là dessus. Il se trouve qu'ici nous avons des entiers et dans la très grande majorité des cas le fonctionnement sera identique à ce que nous avons : les entiers valent 0. Cependant, il sera plus difficile de faire la même chose avec des nombres réels. On pourra avoir un nombre réel qui a tous ces bits à 0 de manière interne mais qui ne vaut pas forcément 0. Il faudra donc faire attention à ne pas trop se reposer sur calloc()

Sinon, à part ce petit point de détail, il n'y pas de grande difficulté, on commence par créer notre tableau de tableau via la fonction malloc(). On utilise la fonction malloc() ici mais on pourrai utiliser calloc(), c'est juste pour vous montrer que l'on peut utiliser les deux. Ensuite, pour chacune des cases de notre tableau, on crée un tableau d'entier via la fonction calloc(), ce qui nous permet de mettre toutes les cases du tableau à la valeur 0. Nous verrons dans la dernière partie quelques macros utiles qui allégeront le code pour ne pas avoir à tester les valeurs de retour des fonctions d'allocations.

Lorsque vous allouez un pointeur d'entier, vous effectuez ceci :

				long *pl = malloc( sizeof(long) );

Ceci est correct et c'est comme ceci que nous l'avons fait jusqu'à présent. Cependant, si vous devez changer le type qui doit être alloué dynamiquement, vous devrez à la fois changer le type du pointeur et le type qui est utilisé par l'opérateur sizeof. On peut se demander s'il n'y a pas moyen de faire plus simple. Et bien oui, il suffit tout simplement de donner à sizeof le pointeur que l'on veut allouer : voici ce que celà donne :

				long *pl = malloc ( sizeof *pl );

Par conséquent, si vous désirez allouer un entier long non signé vous n'aurez qu'à modifer le type du pointeur comme ceci :

				unsigned long *pl = malloc ( sizeof *pl );

Ainsi, on a plus qu'une seule modification à apporter.

La première macro est une macro pour remplacer la fonction malloc(). Vous n'aurez qu'à donner le pointeur qui vous sert à l'allocation, le type que vous voulez allouer et le nombre d'élément à allouer. La fonction teste la valeur de retour de l'allocation, et en cas d'erreur, elle vous fourni un message d'erreur contenant le nom du fichier dans lequel s'est produite l'erreur et le numéro de la ligne ou s'est produite l'erreur. Attention cependant, les macros suivantes sont ici pour vous indiquer la marche à suivre, elles ne sont pas totalement correcte, en effet, celles ci ne gèrent pas les effets de bord et ne tolère que les instructions simples. C'est à dire que pour allouer un bloc de taille n, n ne doit pas pas être un calcul mais une valeur.

Voici donc la macro :

#define MALLOC(_p,_t,_n) do{ \
(_p) = malloc ( (_n) * sizeof( (_t) )); \
if( (_p) == NULL ) \
{ \
     fprintf(stderr,"Allocation impossible dans le fichier :%s ligne : %s",__FILE__,__LINE__);\
     exit(EXIT_FAILURE); \
} \
}while(0)

La deuxième macro s'occupe de la fonction calloc() elle effectue la même chose que pour la fonction précédente :

#define CALLOC(_p,_t,_n) do{ \
(_p) = calloc ( (_n) , sizeof( (_t) ) ); \
if( (_p) == NULL ) \
{ \
     fprintf(stderr,"Allocation impossible dans le fichier :%s ligne : %s",__FILE__,__LINE__);\
     exit(EXIT_FAILURE); \
} \
}while(0)

La troisième macro réalise une réallocation mémoire pour un tableau, la macro prend en paramètre le tableau originel, le type des éléments et la nouvelle taille.

#define REALLOC(_p,_t,_n) do{ \
(_t) * temp; \
temp = realloc ( (_p) , (_n) * sizeof( (_t) ) ); \
if( temp == NULL ) \
{ \
     fprintf(stderr,"Allocation impossible dans le fichier :%s ligne : %s",__FILE__,__LINE__);\
     free( (_p) ); \
	 exit(EXIT_FAILURE); \
} \
else \
{ \
     (_p) = temp; \
} \
}while(0)

Enfin voici une macro pour la libération de mémoire :

#define FREE(_p) do{ \
	 free( (_p) ); \
     (_p) = NULL; \
}while(0)

Voilà donc pour ces petites macros, voyons un exemple qui illustre leur utilisation :

int ** matrice , i;         /* un tableau à deux dimension */

/*allocation d'un tableau de trois tableaux d'entiers */
MALLOC(matrice,int*,3);    

for ( i = 0 ; i < 3 ; i ++ )
{
     /* allocation d'un tableau de tableau */
     CALLOC(matrice[i],int,3); 
}

/*remplissage d'une matrice diagonale*/
for ( i = 0 ; i < 3 ; i++ )
{
      matrice[i][i] = 1;
}

for(i = 0 ; i<3 ; i++)
{
     FREE(matrice[i]);
}
FREE(matrice);

Les macros allègent donc votre code en évitant d'écrire des tests pour vérifier la bonne exécution des allocations ou désallocations. Mais attention cependant, pour vos programmes, ne les utilisez pas en l'état. (il faudrait gérer les effets de bord mais ce n'est pas le sujet de cet article).