Vous êtes sur la page 1sur 11

Exercice

Complétez le tableau pour chaque instruction du programme ci-contre

1
Université Ibn Zohr - Faculté des Sciences

SMI3

Programmation I
Allocation dynamique

2
Jusqu’à maintenant, on a vu que tous les objets (variables) ainsi que leur
taille devaient être déclarés au moment de la compilation, c-à-d explicitement
dans le code C.
En particulier, la dimension des tableaux doit être connue au moment de
l’écriture du programme et ne peut être modifiée au moment de l’exécution.
Les fonctions de gestion "dynamique" de mémoire permettent de remédier à
cette limitation.

2 fonctions de base :

malloc() : allocation d'une zone de mémoire

free() : libération d'une zone mémoire précédemment alloué grâce à malloc

3
la fonction malloc permet de réserver n octets contigus (un tableau) dans la
mémoire.
La valeur de retour est l'adresse du premier octet réservé.

Exemple :
int * t; /*t est un pointeur d'entier*/
int n;
printf("combien d entiers voulez-vous réserver ? \n");
scanf("%d",&n);
t = (int*) malloc (n*sizeof(int));
Calcul du nombre
conversion de d'octets
type

4
Exemple :
int * t; /* t est un pointeur d'entier */
int n;
…. Prototype
t = (int*) malloc (n*sizeof(int));
.. void * malloc (int n) ;
/* accès aux éléments */
*t = … /* 1ère case ou bien t[0] nombre d'octets
*(t+1)=… /* 2ème case ou bien t[1] type de
pointeur
*(t+2)=… /* 3ème case ou bien t[2]

*(t+i)=… /* ième case ou bien t[i]

En fait, on a "réservé" un tableau de n cases


5
La fonction free permet de libérer l'espace mémoire alloué par un malloc précédent.
Exemple :
int * pt;
int n;
… /*t1*/

pt = (int*) malloc(n*sizeof(int)); /*t2*/



free (pt); /*t3*/

n n n
pt pt pt

/*t1*/ /*t2*/ /*t3*/


6
Remarque :
Après free, pt ne vaut pas NULL et il indique pourtant une adresse inaccessible.

n
pt

/*t3*/

Faire toujours suivre un free par une mise à NULL du pointeur


free (pt); /*t3*/
pt=NULL;

7
l'adresse donnée comme paramètre à la fonction free doit correspondre à
une adresse renvoyée par un malloc précédent

int * pt;
int n;
pt = (int*) malloc(n*sizeof(int));
pt = pt+1
free (pt); => ERREUR

8
Il ne faut jamais "oublier" l'adresse renvoyée par un malloc, seul moyen
d'atteindre les cases réservées => risque de saturation de la mémoire

int * pt;

Libre
pt = (int*) malloc(sizeof(int)); /*t1*/
Occupé
pt = (int*) malloc(sizeof(int)); /*t2*/ Occupé inaccessible
pt = (int*) malloc(sizeof(int)); /*t3*/

pt pt pt

/*t1*/ /*t2*/ /*t3*/

9
• calloc : idem malloc + initialisation des cases réservées à 0

• realloc : permet d'agarandir une zone mémoire déjà réservée

Exemple :
scanf ("%d", &taille);
t = (int *) malloc (taille*sizeof(int));
……..
……..
nouvelle_taille = taille+100;
t =(int *) realloc(t, nouvelle_taille*sizeof(int));

10
Exercice (avec pointeurs)
• Remplir un tableau dynamique de dimension N par
des valeurs paires (remplissage automatique) et
afficher le tableau.
• Ajouter à ce programme un bloc qui permet de
classer les éléments du tableau T par ordre croissant.
• Ajouter à ce programme un bloc qui permet de saisir
un nombre M, de compter le nombre d’élément de T
qui sont inférieurs à M et de l’insérer à son
emplacement approprié.

11