Apprendre Malloc et Free

Ces fonctions permettent de créer de nouveaux objets non pas lors de la compilation, mais pendant l'exécution du programme, ce qui autorise l'utilisation de l'allocation dynamique de mémoire.

malloc()

Auparavant, pour allouer de la mémoire à nos données, il suffisait de déclarer :

int x;

Désormais, avec la fonction malloc(), il est possible d'allouer de la mémoire dynamiquement :

int* pX = (int*)malloc(4);

La fonction malloc() nécessite en argument le nombre d'octets à allouer. Si la taille en octets requise n'est pas connue, mais que le type de données à stocker l'est, il est possible d'adapter l'expression ainsi :

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

Que se passe-t-il ensuite ? Remarquez que le résultat de la fonction malloc() est affecté à un pointeur. Cela signifie que malloc() retourne une adresse !

Le préfixe (int*) est un cast explicite. Nous spécifions manuellement le type souhaité. Par exemple :

double x = 3.14;
int y = (int)x;   // `y` = 3

Main.c


              1234567891011
            
#include <stdio.h>
#include <stdlib.h> // new header file!

int main()
{
    int* pX = (int*)malloc(sizeof(int));
    
    printf("Address of allocated memory: %p\n", pX);
 
    return 0;
}

Remarque

Veiller à inclure le fichier d’en-tête stdlib.h. Il contient le prototype de la fonction malloc().

Pour stocker des données à l’adresse fournie par la fonction malloc(), utiliser l’opérateur de déréférencement.

Main.c


              123456789101112
            
#include <stdio.h>
#include <stdlib.h> 

int main()
{
    int* pX = (int*)malloc(sizeof(int));
    
    *pX = 100;

    printf(" Value %d at address %p\n", *pX, pX);
    return 0;
}

Est-il possible de libérer de la mémoire ? – Oui, mais uniquement la mémoire allouée par malloc() et des fonctions similaires.

free()

Cette fonction s'utilise avec des pointeurs. Pour illustrer, développons l'exemple ci-dessus :

Main.c


              1234567891011121314151617
            
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int* pX = (int*)malloc(sizeof(int));
    
    *pX = 100;

    printf(" Value %d at address %p\n", *pX, pX);

    free(pX);

    printf("After `free()` value %d at address %p\n", *pX, pX);

    return 0;
}

Fait intéressant, même après avoir "supprimé" un pointeur, celui-ci reste fonctionnel, mais la valeur stockée à l'emplacement mémoire associé devient corrompue.

Cela engendre un problème : une cellule mémoire occupée contient désormais des données non fiables. Pour éviter ces pointeurs, le pointeur utilisé doit être réinitialisé à NULL.

Main.c


              1234567891011121314151617
            
#include <stdio.h>
#include <stdlib.h> 

int main()
{
    int* pX = (int*)malloc(sizeof(int));
    
    *pX = 100;

    printf("Value %d at address %p\n", *pX, pX);

    free(pX);

    pX = NULL;

    return 0;
}

Définir un pointeur à NULL après avoir libéré sa mémoire est une méthode explicite pour indiquer que le pointeur ne référence plus une adresse mémoire valide.

Toujours vérifier si le pointeur est NULL avant de l'utiliser afin de s'assurer qu'il n'accède pas à une mémoire invalide ou déjà allouée.

Tout était clair ?

Merci pour vos commentaires !

Section 6. Chapitre 4

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Awesome!

Completion rate improved to 2.63

Glissez pour afficher le menu

malloc()

Auparavant, pour allouer de la mémoire à nos données, il suffisait de déclarer :

int x;

Désormais, avec la fonction malloc(), il est possible d'allouer de la mémoire dynamiquement :

int* pX = (int*)malloc(4);

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

Que se passe-t-il ensuite ? Remarquez que le résultat de la fonction malloc() est affecté à un pointeur. Cela signifie que malloc() retourne une adresse !

Le préfixe (int*) est un cast explicite. Nous spécifions manuellement le type souhaité. Par exemple :

double x = 3.14;
int y = (int)x;   // `y` = 3

Main.c


              1234567891011
            
#include <stdio.h>
#include <stdlib.h> // new header file!

int main()
{
    int* pX = (int*)malloc(sizeof(int));
    
    printf("Address of allocated memory: %p\n", pX);
 
    return 0;
}

Remarque

Veiller à inclure le fichier d’en-tête stdlib.h. Il contient le prototype de la fonction malloc().

Pour stocker des données à l’adresse fournie par la fonction malloc(), utiliser l’opérateur de déréférencement.

Main.c


              123456789101112
            
#include <stdio.h>
#include <stdlib.h> 

int main()
{
    int* pX = (int*)malloc(sizeof(int));
    
    *pX = 100;

    printf(" Value %d at address %p\n", *pX, pX);
    return 0;
}

Est-il possible de libérer de la mémoire ? – Oui, mais uniquement la mémoire allouée par malloc() et des fonctions similaires.

free()

Cette fonction s'utilise avec des pointeurs. Pour illustrer, développons l'exemple ci-dessus :

Main.c


              1234567891011121314151617
            
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int* pX = (int*)malloc(sizeof(int));
    
    *pX = 100;

    printf(" Value %d at address %p\n", *pX, pX);

    free(pX);

    printf("After `free()` value %d at address %p\n", *pX, pX);

    return 0;
}

Fait intéressant, même après avoir "supprimé" un pointeur, celui-ci reste fonctionnel, mais la valeur stockée à l'emplacement mémoire associé devient corrompue.

Cela engendre un problème : une cellule mémoire occupée contient désormais des données non fiables. Pour éviter ces pointeurs, le pointeur utilisé doit être réinitialisé à NULL.

Main.c


              1234567891011121314151617
            
#include <stdio.h>
#include <stdlib.h> 

int main()
{
    int* pX = (int*)malloc(sizeof(int));
    
    *pX = 100;

    printf("Value %d at address %p\n", *pX, pX);

    free(pX);

    pX = NULL;

    return 0;
}

Définir un pointeur à NULL après avoir libéré sa mémoire est une méthode explicite pour indiquer que le pointeur ne référence plus une adresse mémoire valide.

Toujours vérifier si le pointeur est NULL avant de l'utiliser afin de s'assurer qu'il n'accède pas à une mémoire invalide ou déjà allouée.

Tout était clair ?

Merci pour vos commentaires !

Section 6. Chapitre 4