2
Allocation dynamique
1 Allocation dynamique
Allocation de mémoire dynamique
Objectif : apprendre à demander de la mémoire manuellement (dynamiquement).
On va avoir besoin d'inclure la bibliothèque <stdlib.h>. Cette bibliothèque contient trois fonctions
dont nous allons avoir besoin :
---------- malloc() (« Memory ALLOCation », c'est-à-dire « Allocation de mémoire ») : demande au
système d'exploitation la permission d'utiliser un bloc (zone) mémoire sans modifier le contenu de
ce bloc.
---------- calloc() : demande au système d'exploitation la permission d'utiliser un bloc de mémoire
en initialisant tous ces octets de ce bloc à la valeur 0.
---------- free() (« Libérer ») : permet d'indiquer au système d'exploitation que l'on n'a plus besoin
du bloc mémoire qu'on avait demandée. La place en mémoire est libérée.
---------- realloc() : Si la mémoire allouée précédemment à l'aide de malloc ou calloc est
insuffisante, realloc peut être utilisé pour réaffecter dynamiquement de la mémoire.
Nadif Sami, EMSI 1/13
1 Allocation dynamique
Allocation de mémoire dynamique
Quand vous faites une allocation dynamique de la mémoire, vous devez toujours suivre ces trois
étapes :
1. Appeler malloc/calloc pour demander de la mémoire.
2. Vérifier la valeur retournée par malloc/calloc pour savoir si le système d'exploitation a bien
réussi à allouer la mémoire.
3. Une fois qu'on a fini d'utiliser la mémoire, on doit la libérer avec free.
Nadif Sami, EMSI 2/13
1 Allocation dynamique
La fonction malloc()
Le prototype de la fonction malloc est le suivant :
void* malloc( size_t nombreOctetsNecessaires )
- nombreOctetsNecessaires (paramètre) : Le nombre d'octets (dont vous avez besoin) à réserver .
- void* : Si tout ce passe bien, la fonction vous renvoie l’adresse de la zone nouvellement allouée.
Remaque : La fonction malloc ne sait pas quel type de variable vous cherchez à créer. En effet,
vous ne lui donnez qu'un paramètre : le nombre d'octets en mémoire dont vous avez besoin. Si
vous demandez 4 octets, ça pourrait bien être un int ou un float.
Comme malloc ne sait pas quel type d’adresse elle doit retourner, elle renvoie le type void*.
Nadif Sami, EMSI 3/13
1 Allocation dynamique
La fonction malloc()
Exemple (Code C) :
void main( void )
{
int* memoireAllouee = NULL ;
memoireAllouee = malloc( sizeof(int) ) ;
if (memoireAllouee == NULL)
{
printf( "erreur" ) ;
}
}
La fonction malloc a donc renvoyé dans notre pointeur memoireAllouee l'adresse qui a été
réservée pour vous en mémoire.
Il y’a deux possibilités :
- Si l'allocation a marché, notre pointeur contient une adresse.
- Si l'allocation a échoué, notre pointeur contient l'adresse (mot-clé) NULL.
Nadif Sami, EMSI 4/13
1 Allocation dynamique
La fonction calloc()
Le prototype de la fonction calloc est le suivant :
void* calloc( size_t nombreElements, size_t nombreOctetsElement )
Cette fonction alloue un bloc de mémoire en initialisant tous ces octets à la valeur 0. Bien que
relativement proche de la fonction malloc, deux aspects les différencient :
- L'initialisation : calloc met tous les octets du bloc à la valeur 0 alors que malloc ne modifie pas le
contenu du bloc mémoire.
- Les paramètres d'appels : calloc requière deux paramètres (le nombre d'éléments consécutifs
(nombreElements) à allouer et la taille d'un élément (nombreOctetsElement)) alors que malloc
prend en paramètre la taille totale du bloc à allouer.
Nadif Sami, EMSI 5/13
1 Allocation dynamique
La fonction calloc()
Exemple (Code C) :
void main( void )
{
int* memoireAllouee = NULL ;
memoireAllouee = calloc( 1 , sizeof(int) ) ;
if (memoireAllouee == NULL)
{
printf( "erreur" ) ;
}
printf( "%d" , *memoireAllouee ) ;
}
Affichage (Console) : 0
Nadif Sami, EMSI 6/13
1 Allocation dynamique
La fonction free()
Le prototype de la fonction free est le suivant :
void free(void* PTR_Adresse)
- PTR_Adresse (paramètre) : La fonction free a juste besoin de l'adresse mémoire à libérer.
- void (sortie) : La fonction free ne retourne rien.
Exemple (Code C) :
void main( void )
{
int* memoireAllouee = NULL ;
memoireAllouee = malloc( sizeof(int) ) ;
// instructions
free( memoireAllouee ) ;
}
Nadif Sami, EMSI 7/13
1 Allocation dynamique
La fonction realloc()
Le prototype de la fonction realloc est le suivant :
void* realloc (void* PTR_Adresse, size_t nombreOctets)
- La fonction realloc modifie la taille d’un bloc mémoire pointé par PTR_ Adresse pour l’amener à
une taille de nombreOctets octets.
- void* : Si tout ce passe bien, la fonction vous renvoie l’adresse de la zone nouvellement allouée.
Remaque : Realloc() réalloue une nouvelle zone mémoire et recopie l’ancienne dans la nouvelle
sans initialiser le reste.
Nadif Sami, EMSI 8/13
1 Allocation dynamique
Exercice 1 :
Réécrire le code suivant en remplaçant l’instruction int age ; par l’instruction int *age ; .
void main( void )
{
int age ;
printf( "Quel age avez-vous ?" ) ;
scanf( "%d", &age ) ;
printf( "Votre age est : %d ans \n", age ) ;
}
Nadif Sami, EMSI 9/13
1 Allocation dynamique
Allocation dynamique d'un tableau
Pour le moment, on a utilisé l'allocation dynamique uniquement pour créer une petite variable. Or
en général, on ne se sert pas de l'allocation dynamique pour cela. On utilise la méthode
automatique qui est plus simple. Le plus souvent, on s'en sert pour créer un tableau dont on ne
connaît pas la taille avant l'exécution du programme.
Tableau Statique :
Syntaxe : type Nom_du_tableau [ taille ]
Tableau dynamique :
Syntaxe 1 : type *Nom_du_tableau = malloc( sizeof(type) * taille )
Syntaxe 2 : type *Nom_du_tableau = calloc( taille , sizeof(type) )
Nadif Sami, EMSI 10/13
1 Allocation dynamique
Exercice 2 :
Réécrire le code suivant pour qu’il marche dans tous les compilateurs .
void main( void )
{
int taille ;
printf( "Donner la taille de votre tableau ?" ) ;
scanf( "%d", &taille ) ;
int Tab [ taille ] ;
}
Nadif Sami, EMSI 11/13
1 Allocation dynamique
Allocation dynamique d'un tableau
Vous pouvez augumenter / diminuer la taille d’un tableau dynamique en utilisant la fonction
realloc() :
Syntaxe : Nom_du_tableau = realloc ( Nom_du_tableau , NouvelleTaille )
Exemple (Code C) :
void main( void )
{
int *Tab = malloc( sizeof(int) * 5 ) ;
// instructions
tab = realloc( tab , 10 ) ;
}
Nadif Sami, EMSI 12/13
1 Allocation dynamique
Résumé
- Une variable occupe plus ou moins d'espace en mémoire en fonction de son type.
- On peut connaître le nombre d'octets occupés par un type à l'aide de la fonction sizeof().
- L'allocation dynamique consiste à réserver manuellement de l'espace en mémoire pour une
variable ou un tableau.
- L'allocation est effectuée avec malloc() ou calloc() et il ne faut surtout pas oublier de libérer la
mémoire avec free() dès qu'on n'en a plus besoin.
- L'allocation dynamique permet notamment de créer un tableau dont la taille est déterminée par
une variable au moment de l'exécution.
- La fonction realloc() permet d’augumenter / diminuer la taille d’un tableau dynamique.
Nadif Sami, EMSI 13/13