Allocation de mémoire

L'allocation statique se fait au moment de l'initialisation du programme, avant son exécution proprement dite. L'espace alloué statiquement est déjà pré-réservé dans le fichier exécutable du programme lorsque le système d'exploitation charge le programme en mémoire pour l'exécuter.

Allouer statiquement de la mémoire pour un programme signifie :

• prévoir l'espace mémoire nécessaire avant l'exécution du programme, en spécifiant la quantité nécessaire dans le code source ;
• réserver cet espace au moment de la compilation, dans le fichier binaire produit ;
• au chargement du programme en mémoire, juste avant l'exécution, l'espace réservé devient alors accessible.

Lors de l'exécution, aucune allocation statique ne peut avoir lieu.

L'avantage de l'allocation statique se situe essentiellement au niveau des performances, puisqu'on évite les coûts de l'allocation dynamique à l'exécution : la mémoire statique est immédiatement utilisable.

Sur les systèmes d'exploitation communs, la mémoire allouée statiquement est placée dans le segment text, le segment de données ou le segment BSS du programme, selon le destin de cette zone mémoire (réservée, initialisée, lecture seule…).

L'allocation dynamique se fait pendant l'exécution du programme, ce qui signifie que l'espace alloué dynamiquement ne se trouve pas déjà dans le fichier exécutable du programme lorsque le système d'exploitation charge le programme en mémoire pour l'exécuter ; la demande d'allocation d'espace au système d'exploitation se fait durant l'exécution du programme.

L'exécution d'un programme utilise généralement une pile contenant les cadres d'appel aux routines (fonctions ou procédures) du langage de programmation utilisé. Schématiquement, les variables lexicales, c'est-à-dire les variables définies dans la portée textuelle d'une routine, sont :

• allouées lors de l'entrée dans la routine (entrée de la portée), c'est-à-dire que l'espace est réservé pour ces variables;
• désallouées automatiquement lors de la sortie de la routine (sortie de la portée), c'est-à-dire que l'espace réservé pour ces variables est dorénavant libre et disponible pour d'autres variables.

Un segment mémoire, dit segment de pile, est utilisé pour ces allocations/libération. Aucun mot clef n'est nécessaire dans le code source du langage supportant la notion de variable lexicale : l'espace est alloué et libéré selon la discipline de pile par définition.

Certains langages, comme le C ou le C++, parlent de variables automatiques au lieu de variables lexicales, mais il s'agit de la même chose.

La plupart des programmes ayant des besoins en mémoire dépendant de l'usage qu'on en fait, il est nécessaire de pouvoir, à des moments arbitraires de l'exécution, demander au système d'exploitation d'allouer de nouvelles zones de mémoire, et de pouvoir restituer au système ces zones (libérer la mémoire). Le système d'exploitation utilise une table pour gérer le tas où il enregistre pour chaque bloc de mémoire alloué:

• l'adresse de début du bloc de mémoire alloué;
• la taille en octets du bloc de mémoire alloué.

La gestion de l'allocation et de la libération de la mémoire est sous la responsabilité du programmeur.

Les langages de programmation dotés de ramasse-miettes utilisent, mais de façon transparente pour le programmeur, l'allocation sur le tas et les primitives *alloc/free. Dans ce dernier cas, le ramasse-miettes permet au développeur de ne pas se soucier de la libération des ressources.

Les fuites de mémoire, qui se produisent aussi bien sous un système d'exploitation avec une interface de ligne (exemple: DOS) qu'avec une interface d'utilisation graphique (exemple: Windows), ainsi que d'autres erreurs fréquentes dans les programmes à gestion manuelle de la mémoire, ont leur source dans les erreurs d'allocation mémoire sur le tas.

Classiquement, les fonctions malloc et free des bibliothèques standard du langage C ainsi que les opérateurs new et delete du langage C++ permettent, respectivement, d'allouer et de libérer la mémoire sur le tas.

int UtiliserAllocationDynamiqueDeMemoire ( int Nb )
{
    // Pointeur vers la mémoire allouée dynamiquement.
    int *pInt = NULL;
    
    // Demander l'allocation dynamique de l'espace mémoire nécessaire pour une liste de «Nb» nombres entiers.
    pInt = (int *) malloc ( Nb * sizeof(int) );
    
    // Si l'espace mémoire demandé a bien été alloué
    if ( pInt != NULL )
    {
        // Utiliser l’espace mémoire alloué.
        
        // ...
        
        // Libérer l'espace mémoire alloué.
        free (pInt);
    }// Fin du si.
    
    // Retourner le code d'erreur à la routine appelante.
    return 0;
}