Les classes de stockage en langage C

Classes de stockage en C

1. Classe automatique — auto

auto int age;        /* explicite — rarement écrit */
int  age;            /* équivalent — classe auto implicite */

Exemple n°1 — Portée de blocs imbriqués avec auto

#include <stdio.h>

int main(void)
{
    auto int j = 1;           /* bloc 1 */
    {
        auto int j = 2;       /* bloc 2 — nouvelle variable j, masque le j du bloc 1 */
        {
            auto int j = 3;   /* bloc 3 — nouvelle variable j, masque les deux précédentes */
            printf("bloc 3 — j = %d\n", j);
        }                     /* j de bloc 3 détruite ici */
        printf("bloc 2 — j = %d\n", j);
    }                         /* j de bloc 2 détruite ici */
    printf("bloc 1 — j = %d\n", j);
    return 0;
}                             /* j de bloc 1 détruite ici */

bloc 3 — j = 3
bloc 2 — j = 2
bloc 1 — j = 1

Chaque bloc possède sa propre variable j indépendante. À la sortie d'un bloc, la variable locale est détruite et la variable du bloc parent redevient visible.

2. Classe externe — extern

/* Fichier A — définition (une seule fois dans tout le projet) */
int compteur = 3;

/* Fichier B — déclaration (autant de fichiers que nécessaire) */
extern int compteur;   /* pas d'initialisation — la variable existe déjà dans A */

Exemple n°2 — Variable partagée entre deux fichiers

/* ───── main.c ───── */
#include <stdio.h>

int compteur;                   /* définition — mémoire allouée ici */
extern void methode_globale(void);

int main(void)
{
    compteur = 3;
    methode_globale();
    return 0;
}

/* ───── utilitaire.c ───── */
#include <stdio.h>

extern int compteur;            /* déclaration — pas de nouvelle allocation */

void methode_globale(void)
{
    printf("compteur est : %d\n", compteur);
}

gcc main.c utilitaire.c -o main
./main

compteur est : 3

extern int x = 5;   /* incorrect — extern + initialisation = redéfinition */
extern int x;       /* correct   — simple déclaration */

3. Classe statique — static

static int compteur = 10;   /* variable statique — initialisée une seule fois */

Exemple n°3 — Variable locale statique qui persiste entre les appels

#include <stdio.h>

void func(void);

static int compteur = 3;   /* globale statique — visible dans ce fichier uniquement */

int main(void)
{
    while (compteur--) {
        func();
    }
    return 0;
}

void func(void)
{
    static int i = 5;   /* initialisée à 5 une seule fois — conserve sa valeur */
    i++;
    printf("i = %d  |  compteur = %d\n", i, compteur);
}

i = 6  |  compteur = 2
i = 7  |  compteur = 1
i = 8  |  compteur = 0

La variable locale i conserve sa valeur (6, puis 7, puis 8) d'un appel à l'autre. Sans static, elle serait réinitialisée à 5 à chaque appel.

Exemple n°4 — Compteur d'appels avec variable statique

#include <stdio.h>

void compter_appels(void)
{
    static int nb = 0;   /* initialisée à 0 une seule fois */
    nb++;
    printf("Appel n°%d\n", nb);
}

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

Appel n°1
Appel n°2
Appel n°3

4. Classe registre — register

register int compteur;   /* suggestion : stocker dans un registre CPU */

Exemple n°5 — Usage typique : compteur de boucle

#include <stdio.h>

int main(void)
{
    register int i;
    long somme = 0;

    for (i = 0; i < 1000000; i++) {
        somme += i;
    }

    printf("Somme = %ld\n", somme);
    return 0;
}

register int poids;
int *ptr = &poids;   /* ERREUR — address of register variable requested */

Récapitulatif