Allocation dynamique de mémoire

 Allocation dynamique de mémoire en C

 Allocation dynamique de mémoire en C++

 Introduction
Normalement, une variable est créée automatiquement lors de sa
déclaration.

Les variables à créer ainsi que leurs tailles sont connues au moment de la
compilation ( but des déclarations).

Les pointeurs sont surtout utilisés pour créer un nombre quelconque de

variables, ou des variables de taille quelconque, en cours d’exécution du
programme.

Si on ne peut pas savoir à l’avance le nombre de données, le compilateur ne

peut donc pas faire la réservation de l’espace mémoire automatiquement.
 C’est alors au programmeur de le faire.

 Cette réservation de mémoire (appelée encore

allocation) doit être faite pendant l’exécution du
programme.

 Si la quantité de mémoire à allouer, est variable, on

parle d’ allocation dynamique de mémoire.
 Stack et Heap
• Stack: pile
• Heap: tas
• Toute variable globale (et variable locale
déclarée "static") est stockée dans le segment
de données.
• Toute variable locale à une fonction (non
"static") est stockée dans la pile (stack).
• Toute zone mémoire allouée dynamiquement
est stockée dans le tas (heap).
Zone mémoire libre

Variables locales
Appels de fonctions

Variables globales Data segment

Variables static (segment de données)

instructions
 Allocation dynamique de mémoire en C

Il existe deux principales fonctions C :

• malloc(taille)
• free(pointeur)
 malloc et free sont définies dans <stdlib.h>
 malloc (abréviation de « Memory ALLOCation ») alloue de la mémoire.
Elle attend comme paramètre la taille de la zone de mémoire à allouer en
bytes.
 Elle renvoie un pointeur non typé (void *).
free (pour « FREE memory ») libère la mémoire allouée.
 Elle attend comme paramètre le pointeur sur la zone à libérer
Elle ne renvoie rien.
Lorsqu’on alloue de la mémoire pour une variable typée, on doit faire un
transtypage du pointeur renvoyé par malloc en pointeur de ce type de
variable.
Syntaxe:

malloc ( taille );
free(nom-du-pointeur);

La fonction malloc demande au système d'exploitation un bloc de taille bytes et

renvoie un pointeur vers l'adresse du bloc alloué.
S'il se produit une erreur ( il n'y a plus de mémoire disponible), cette fonction
renvoie la valeur NULL.

Exemple:
int * p;
p = malloc (sizeof(int)); // (int*)malloc(sizeof(int));

Vérification de la réussite de l’allocation:

int * p;
p = malloc (sizeof(int));
if ( p == NULL )
{ fprintf(stderr,"Allocation impossible \n"); // return -1;
exit(EXIT_FAILURE); }
Exemple:

#include <stdio.h> /* Autorise l’utilisation de printf et de scanf. */

#include <stdlib.h> /* Autorise l’utilisation de malloc et de free. */

int (*pi)[10][10]; /* Déclare un pointeur d’entier, qui sera utilisé comme

un tableau de n matrices 10*10. */
int main(void)
{
unsigned int taille; /* Taille du tableau (non connue à la compilation) */
printf("Entrez la taille du tableau : ");
scanf("%u",&taille);
pi = (int (*)[10][10]) malloc(taille * sizeof(int)*10*10);
/* Ici se place la section utilisant le tableau. */
free(pi); /* Attention à ne jamais oublier de restituer la mémoire allouée
par vos programmes ! */
return 0;
}
 Allocation dynamique en C++
 C++ fournit, en plus des fonctions malloc et free,
d’autres moyens pour allouer et restituer la mémoire:
 new allocation de mémoire
 new[]
 delete
 delete[] restitution
 syntaxe :
 new type
 delete pointeur
 new type[taille]
 delete[] pointeur
Exemple: allocation et restitution d’un entier :
Allocation:

int *pi = new int ; // équivalent à (int *)malloc(sizeof(int)).

 Restitution:
La syntaxe de delete est encore plus simple,
puisqu’il suffit de faire suivre le mot-clé delete
du pointeur sur la zone mémoire à libérer :

delete pi ; // équivalent à free(pi) ;

Les opérateurs new[] et delete[] sont utilisés pour
allouer et restituer la mémoire pour les tableaux.

Exemple:

int *Tableau=new int[50000] ; // allocation

delete[] Tableau ; /* destruction du tableau et

restitution de la zone mémoire */
Attention:
1) il ne faut jamais mélanger les paires d’opérateurs
utilisés pour l’allocation et la restitution de la
mémoire:(malloc, free);(new, delete); (new[], delete[])

2) L’opérateur new[] alloue la mémoire et crée les

objets dans l’ordre croissant des adresses.
Inversement, l’opérateur delete[] détruit les objets
du tableau dans l’ordre décroissant des adresses.

3) Lorsqu’il n’y a pas assez de mémoire disponible, les

opérateurs new et new[] peuvent se comporter de deux
manières selon l’implémentation. Le comportement le
plus répandu est de renvoyer un pointeur nul (NULL).
Exemple 1:

#include<iostream.h>
int main ()
{
int * p1 =new int; //pointeur sur un entier
*p1 = 10; //écrit 10 dans la zone mémoire allouée
cout << *p1 << endl; /* lit et affiche le contenu de
la zone mémoire
allouée */
delete p1; // libère la zone mémoire allouée
return 0;
}
Exemple: cas d’un tableau
#include<iostream.h>
int main ()
{
int *p25= new int[25]; //allocation de mémoire pour 25 entiers
cout <<"la valeur de p25 est "<< p25 << endl; // ?
for (int i=0;i<25;i++) // initialisation du tableau à 0
{
*(p25+i)=0; // ou bien p25[i]=0;
cout << "p25["<<i <<"]="<< p25[i]<<endl;
cout << "adresse["<<i <<"]="<< &p25[i]<<endl;
}
delete[] p25; // libération de la mémoire
return 0;
}