Présentation de la mémoire des programmes C

Organisation de la mémoire en C

Quand un programme C est chargé et exécuté, le système d'exploitation lui alloue un espace mémoire structuré en cinq segments distincts, chacun ayant un rôle précis. Comprendre cette organisation est essentiel pour maîtriser la durée de vie des variables, les pointeurs et l'allocation dynamique.

1. Segment de texte (code)

Le segment de texte possède deux propriétés importantes :

• Partageable : plusieurs instances du même programme (p. ex. plusieurs terminaux ouverts) partagent une seule copie du segment de texte en mémoire.
• Lecture seule : le programme ne peut pas modifier ses propres instructions — toute tentative provoque une erreur de protection mémoire.

2. Segment de données initialisées

Exemple n°1 — Variables placées dans le segment de données

/* Toutes ces variables sont dans le segment de données initialisées */

int compteur = 10;              /* zone lecture/écriture */
char ville[] = "Meknes";       /* zone lecture/écriture — tableau modifiable */
const char *msg = "bonjour";   /* pointeur en RW, littéral "bonjour" en RO  */

int main(void)
{
    static int appels = 1;     /* variable statique locale — segment de données */
    return 0;
}

void compter()
{
    static int n = 0;   /* initialisée une seule fois */
    n++;
    printf("%d\n", n);
}
/* Appels successifs affichent : 1, 2, 3, … */

3. Segment BSS (données non initialisées)

Exemple n°2 — Variables placées dans le segment BSS

int x;              /* global, non initialisée → BSS, vaut 0 */
int y = 0;          /* global, initialisée à 0  → BSS */
static int z;       /* statique locale, non init → BSS, vaut 0 */

int main(void)
{
    printf("x = %d, y = %d, z = %d\n", x, y, z);
    /* Affiche : x = 0, y = 0, z = 0 */
    return 0;
}

4. La pile (stack)

À chaque appel de fonction, un cadre de pile (stack frame) est créé. Il contient :

• L'adresse de retour (pour reprendre l'exécution après le retour)
• Les paramètres de la fonction
• Les variables locales (variables automatiques)
• Les registres sauvegardés

Exemple n°3 — Cycle de vie d'un cadre de pile

#include <stdio.h>

int additionner(int a, int b)   /* a et b : sur la pile, cadre de additionner */
{
    int resultat = a + b;       /* resultat : sur la pile */
    return resultat;            /* cadre détruit après retour */
}

int main(void)
{
    int x = 3, y = 5;          /* x, y : sur la pile, cadre de main */
    int s = additionner(x, y); /* nouveau cadre créé pour additionner */
    printf("s = %d\n", s);
    return 0;
    /* cadre de main détruit */
}

void infini()
{
    infini();   /* empile sans fin → Segmentation fault */
}

int main(void)
{
    infini();
    return 0;
}

5. Le tas (heap)

#include <stdlib.h>

void *malloc(size_t taille);           /* alloue, contenu indéfini     */
void *calloc(size_t n, size_t taille); /* alloue n éléments + met à 0  */
void *realloc(void *ptr, size_t n);    /* redimensionne un bloc existant */
void  free(void *ptr);                 /* libère le bloc alloué         */

Exemple n°4 — Allocation et libération sur le tas

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

int main(void)
{
    int n = 5;

    /* Allocation de n entiers sur le tas */
    int *tab = (int *)malloc(n * sizeof(int));
    if (tab == NULL)
    {
        fprintf(stderr, "Erreur : allocation échouée\n");
        return 1;
    }

    /* Utilisation */
    for (int i = 0; i < n; i++)
        tab[i] = i * 10;

    for (int i = 0; i < n; i++)
        printf("tab[%d] = %d\n", i, tab[i]);

    /* Libération obligatoire */
    free(tab);
    tab = NULL;   /* bonne pratique : évite un pointeur dangling */

    return 0;
}

tab[0] = 0
tab[1] = 10
tab[2] = 20
tab[3] = 30
tab[4] = 40

void boucle()
{
    for (int i = 0; i < 1000000; i++)
    {
        int *p = malloc(100);   /* alloué… */
        /* free(p) oublié → 100 octets × 1M = ~100 Mo perdus */
    }
}

free(ptr);
ptr = NULL;   /* free(NULL) est sans effet — sans danger */

6. Pile vs Tas — Comparaison

Exemple n°5 — Localisation de différentes variables en mémoire

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

int globale = 42;          /* segment données initialisées */
int bss_var;               /* segment BSS                  */

int main(void)
{
    int locale = 10;                         /* pile          */
    static int statique = 5;                 /* données init  */
    int *dynamique = malloc(sizeof(int));    /* tas           */

    *dynamique = 99;

    printf("globale   (données) : %p\n", (void *)&globale);
    printf("bss_var   (BSS)     : %p\n", (void *)&bss_var);
    printf("statique  (données) : %p\n", (void *)&statique);
    printf("locale    (pile)    : %p\n", (void *)&locale);
    printf("dynamique (tas)     : %p\n", (void *)dynamique);

    free(dynamique);
    return 0;
}

globale   (données) : 0x601040
bss_var   (BSS)     : 0x601044
statique  (données) : 0x601048
locale    (pile)    : 0x7ffee4b2a4ac
dynamique (tas)     : 0x1b72010

Récapitulatif