Allocation dynamique de mémoire

Allocation dynamique de mémoire

Intérêt:

1. Pouvoir utiliser la mémoire “au mieux”

ex: ne pas réserver un tableau de 100 éléments alors qu’à l'exécution du programme seuls 7 éléments seront nécessaires

      2)  Pouvoir créer un tableau dans une fonction et la retourner en l’appelant (éviter le problème de retour de l’adresse d’une variable locale)

      3)  Création d’éléments de structures de données telles que: listes chaînées , arbres, graphes

[pic 1]

Pratique

-fonction d’allocation  → malloc() , calloc(), realloc()

(pour réserver de la mémoire)  

-fonction de libération → free()

(libérer la mémoire)

1. malloc:   demande au système un certain nombre d’octets en mémoire. Le système alloue de la place (dans le tas (heap)) et renvoie l’adresse de début de cette zone.

        Si le système n’a pas plus de mémoire disponible, malloc() renvoie l’adresse NULL

        Prototype  (déclaré dans stdlib.h)

      void *^[a]malloc(size_t^[b]);

        int i = 100;

        malloc(i); //syntaxiquement correcte mais totalement inutile

         char *chaine = NULL;

        chaîne = malloc(i); // OK: chaine pointé vers une zone de 100 octets

        // en général, on écrit plutôt

        chaîne = malloc( i *sizeof(char));

        //ou

        chaine = (char *) malloc( i *sizeof(char));

        if(chaine == NULL){

printf(“Problème d’allocation mémoire\n”);

exit(1); //Sortie du programme

}

//ou

if(( chaine = malloc( i *sizeof (char))) == NULL){

        printf(“Problème d’allocation mémoire\n”);

        exit(1);

}

[pic 2]

Classes d'allocation mémoire

1. automatique: variables locales → dans la pile
2. dynamique: zone mémoire alloués par malloc, calloc ou realloc → dans le tas
3. statique: variables statiques et globales → dans le bss + data

3 types de tableaux

• tableau de taille fixe        char tab[100]; → pile
• tableau alloué dynamiquement :        char *tab = malloc(100 *sizeof(char)); → tas +      adresse dans la pile
• VLA Variable Length Array                 int i;

tableau de longueur variable                 scanf(“%d” , &i);

char tab[i] ;        → pile

déconseillé  : pourquoi ?

1. certains compilateur l’interdisent (ex: Microsoft)
2. N’existe pas en C++

2)calloc : fait (presque) le même travail que malloc

Prototype

     Void *calloc(size_t, size_t);

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

        ou

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

Différence avec malloc : calloc initialise à 0 tous les octets de la zone allouée

• Intérêt : “nettoie” la zone mémoire qui va être utilisée
• Inconvénient : plus lent que malloc

Faille “heart bleed” dans la libssl (secure socket layer)

        3)realloc:

        But : changer la taille d’une zone préalablement allouée = réallocation

Prototype

      Void *realloc( void *, size_t);

ex:         char *chaine  = malloc( 100 *sizeof(char));

 // il faut 100 caractères de plus

              chaine = realloc( chaine, 200*sizeof(char));

...