Réponse.

Historique de la question :

La mémoire stack est présente dans toutes les architectures principales. Dans le langage C, les variables automatiques (locales) sont placées sur la stack, assurant une grande rapidité d'allocation et de libération de mémoire par rapport à la heap dynamique.

Problème :

L'utilisation de la stack est limitée en taille, les variables automatiques sont automatiquement détruites après la sortie du bloc, et un dépassement de la stack (stack overflow) entraîne un arrêt du programme ou une corruption des données.

Solution :

Les variables locales déclarées à l'intérieur des fonctions sans modificateur spécial sont placées sur la stack. Cette zone de stockage automatique est créée à l'entrée dans la fonction et détruite à la sortie. La taille de la stack est limitée et ne peut être modifiée que par des options de liaison/système.

Exemple de code :

#include <stdio.h>

void foo() {
    int arr[100]; // placé sur la stack
    for (int i = 0; i < 100; ++i) arr[i] = i;
    printf("Premier élément : %d\n", arr[0]);
} // arr est détruit après la sortie de foo

Particularités clés :

• Le travail avec des variables sur la stack est très rapide et ne nécessite pas de libération explicite.
• La taille de la stack est limitée - essayer de placer de gros objets entraînera un échec.
• Référencer des variables locales en dehors de leur portée est une erreur grave.

Questions pièges.

Est-il possible de retourner une variable locale d'une fonction par adresse ?

Non, car la variable est détruite après la sortie de la fonction, et le "pointeur suspendu" résultant entraîne un comportement indéterminé.

int* bad() {
    int x = 42;
    return &x; // erreur : le pointeur retourné pointe vers une stack libérée
}

Est-il possible de placer un grand tableau (par exemple, 1 Mo) sur la stack ?

Pour la plupart des systèmes, la stack est limitée (de quelques dizaines à plusieurs centaines de Ko). Essayer de déclarer d'énormes tableaux sur la stack entraînera un stack overflow.

Quelle est la différence entre les variables static et automatiques lors de l'allocation ?

Les variables static (même dans une fonction) sont placées dans une zone de mémoire statique, ne sont pas nettoyées entre les appels, tandis que les variables automatiques sont sur la stack et sont détruites lors de la sortie du bloc.

Erreurs typiques et antipatterns

• Retourner l'adresse d'une variable locale d'une fonction.
• Déclarer un grand objet sur la stack sans vérifier la taille.
• Utiliser des variables automatiques non initialisées.

Exemple de la vie réelle

Cas négatif

Dans une fonction pour des calculs, un tableau de 8192*1024 doubles a été alloué sur la stack. Le programme a reçu un SIGSEGV à l'exécution sous Linux, bien qu'il se soit compilé sans erreurs.

Avantages :

• Pas besoin de libérer explicitement la mémoire.

Inconvénients :

• Stack overflow et arrêt brutal en cas de dépassement de la limite.

Cas positif

Pour travailler avec de gros tampons, une allocation dynamique de mémoire a été utilisée via malloc/free. Sur la stack, seules de petites variables de travail ont été placées.

Avantages :

• Aucun risque de dépassement de la stack.
• Meilleure gestion du cycle de vie et de la taille des objets.

Inconvénients :

• Nécessité de libérer explicitement la mémoire et de vérifier les NULL.