Comprendre les classes de stockage en C : auto, extern, static, register expliqués

Qu'est-ce qu'une classe de stockage en C ?

Une classe de stockage définit la portée, l'emplacement, l'initialisation, la durée de vie et l'accessibilité d'une variable. En C, chaque variable n'est pas seulement typée mais aussi assignée à une classe de stockage qui détermine où et comment elle peut être accédée.

Il y a quatre classes de stockage standard :

• auto – défaut pour les variables locales.
• extern – déclare une variable globale ou fonction existant dans un autre fichier.
• static – préserve la valeur d'une variable entre les appels et limite la visibilité à un fichier ou fonction.
• register – suggère au compilateur de stocker une variable dans un registre CPU pour un accès plus rapide.

Classe de stockage auto

Les variables déclarées avec auto (le défaut pour les variables locales) existent seulement dans le bloc où elles sont définies. Elles sont détruites quand le bloc se termine, et elles sont initialisées avec une valeur indéterminée sauf si explicitement définies.

int add(void) {
    int a = 13;
    auto int b = 48; // auto est optionnel
    return a + b;
}

Démonstration de portée :

#include <stdio.h>
int main(void) {
    auto int j = 1;
    {
        auto int j = 2;
        {
            auto int j = 3;
            printf("%d ", j); // affiche 3
        }
        printf("\t%d ", j); // affiche 2
    }
    printf("%d\n", j); // affiche 1
}

Sortie : 3 2 1

Classe de stockage extern

Le mot-clé extern déclare une variable ou fonction qui est définie dans une autre unité de traduction. Il permet le partage de données entre fichiers sources.

/* main.c */
#include <stdio.h>
extern int i; // déclaration
int main(void) {
    printf("value of the external integer is = %d\n", i);
    return 0;
}

/* original.c */
#include <stdio.h>
int i = 48; // définition

Compilez les deux fichiers ensemble : gcc main.c original.c -o program. L'exécution de ./program affiche :

value of the external integer is = 48

Classe de stockage static

Les variables statiques conservent leur valeur pour la durée du programme. Elles peuvent être utilisées comme statiques locales ou statiques à portée de fichier.

• Statique locale – visible seulement à l'intérieur de la fonction mais persiste entre les appels.
• Statique à portée de fichier – visible seulement dans le fichier où elle est déclarée.

/* global static */
static int counter = 7;
void next(void) {
    /* local static */
    static int iteration = 13;
    iteration++;
    printf("iteration=%d and counter=%d\n", iteration, counter);
}
int main(void) {
    while (counter < 10) {
        next();
        counter++;
    }
    return 0;
}

Sortie :

iteration=14 and counter=7
iteration=15 and counter=8
iteration=16 and counter=9

Classe de stockage register

Utilisez register quand une variable doit être accédée fréquemment et peut tenir dans un registre CPU. Le compilateur peut ignorer l'indication si les registres sont rares.

#include <stdio.h>
int main(void) {
    register int weight;
    /* tenter de prendre son adresse échoue */
    // int *ptr = &weight; // erreur de compilation
    return 0;
}

La compilation du code produit :

error: address of register variable 'weight' requested

Tableau récapitulatif

Classe de stockage	Contexte de déclaration	Emplacement de stockage	Valeur par défaut	Portée	Durée de vie
auto	dans une fonction/bloc	Mémoire	Imprévisible	Fonction/bloc	Fonction/bloc
register	dans une fonction/bloc	Registre CPU	Imprévisible	Fonction/bloc	Fonction/bloc
extern	hors de toutes fonctions	Mémoire	Zéro	Programme entier	Temps d'exécution du programme
static (local)	dans une fonction/bloc	Mémoire	Zéro	Fonction/bloc	Temps d'exécution du programme
static (global)	hors de toutes fonctions	Mémoire	Zéro	Fichier	Temps d'exécution du programme

Points clés à retenir

• Les classes de stockage contrôlent la visibilité et la durée de vie des variables.
• Utilisez auto pour les variables locales standard.
• Utilisez register pour les compteurs critiques en performance (soumis au support du compilateur).
• Utilisez static pour préserver l'état entre les appels de fonction ou limiter la portée au fichier.
• Utilisez extern pour partager des variables ou fonctions entre fichiers sources.