C Academy · Leçon

Variables static

Variables locales persistantes

Variables static est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C Academy comprend 4 leçons au total.

Le mot-clé statique

Une variable locale static conserve sa valeur entre les appels de la fonction. Sa durée de vie couvre tout le programme.

#include <stdio.h>
void f(void) {
    static int count = 0;
    count++;
    printf("count = %d\n", count);
}
int main(void) {
    f();
    f();
    f();
    return 0;
}

Initialisée une seule fois

Une variable statique est initialisée uniquement la première fois que la fonction est exécutée. Les appels suivants ignorent l’initialiseur.

#include <stdio.h>
void f(void) {
    static int x = 100;
    printf("x = %d\n", x);
    x += 10;
}
int main(void) {
    f();
    f();
    return 0;
}

Zéro par défaut

Contrairement aux variables auto, une variable static sans initialiseur commence à 0.

#include <stdio.h>
void f(void) {
    static int n;
    printf("n = %d\n", n);
    n++;
}
int main(void) {
    f();
    f();
    return 0;
}

Compter les appels

Une utilisation classique consiste à compter le nombre d’appels d’une fonction.

#include <stdio.h>
int nextId(void) {
    static int id = 0;
    return ++id;
}
int main(void) {
    printf("%d %d %d\n", nextId(), nextId(), nextId());
    return 0;
}

Durée de vie globale, portée locale

Une variable locale statique conserve une portée locale. Seule la fonction peut la voir, mais elle persiste entre les appels.

#include <stdio.h>
void tick(void) {
    static int t = 0;
    t++;
    printf("tick %d\n", t);
}
int main(void) {
    tick();
    tick();
    return 0;
}

Statique et automatique

Comparez : un compteur auto est réinitialisé à chaque appel, tandis qu’un compteur static cumule les valeurs.

#include <stdio.h>
void autoCounter(void) {
    int c = 0;
    c++;
    printf("auto: %d\n", c);
}
int main(void) {
    autoCounter();
    autoCounter();
    return 0;
}

Statique à la portée du fichier

À la portée du fichier, static signifie liaison interne : la variable est privée à son fichier source.

#include <stdio.h>
static int secret = 7;
int main(void) {
    printf("secret = %d\n", secret);
    return 0;
}

Mise en cache avec le stockage statique

Les variables statiques peuvent mettre en cache une valeur calculée afin qu’elle ne soit calculée qu’une seule fois.

#include <stdio.h>
int getBase(void) {
    static int base = 0;
    if (base == 0) {
        base = 50;
        printf("computed once\n");
    }
    return base;
}
int main(void) {
    printf("%d\n", getBase());
    printf("%d\n", getBase());
    return 0;
}

Accumulation d’un état

Les variables locales statiques permettent à une fonction de mémoriser un total en cours sans variable globale.

#include <stdio.h>
int addToTotal(int v) {
    static int total = 0;
    total += v;
    return total;
}
int main(void) {
    printf("%d\n", addToTotal(10));
    printf("%d\n", addToTotal(5));
    return 0;
}

Une précaution

Un état statique rend une fonction dépendante de son historique, ce qui peut la rendre plus difficile à vérifier. Utilisez-le délibérément.

#include <stdio.h>
int stepNumber(void) {
    static int s = 0;
    return ++s;
}
int main(void) {
    printf("step %d\n", stepNumber());
    printf("step %d\n", stepNumber());
    return 0;
}

Combinaison avec des boucles

Une variable locale statique à l’intérieur du corps d’une boucle conserve sa valeur entre les itérations et les appels.

#include <stdio.h>
void run(void) {
    static int seen = 0;
    for (int i = 0; i < 2; i++)
        seen++;
    printf("seen = %d\n", seen);
}
int main(void) {
    run();
    run();
    return 0;
}

Vérification rapide

Vérifiez votre compréhension des variables statiques.

Récapitulatif : variables statiques

Vous avez découvert les variables locales persistantes.

Les variables locales static existent pendant tout le programme
Elles sont initialisées une seule fois et valent 0 par défaut
Elles conservent une portée locale tout en préservant leurs valeurs
À la portée du fichier, static fournit une liaison interne
Elles sont idéales pour les compteurs et les caches

Questions Fréquemment Posées

La leçon « Variables static » est-elle gratuite ?

Oui — le texte complet de « Variables static » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C Academy, passe à CoddyKit PRO. Le cours C Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Variables static » ?

Variables locales persistantes Tu pratiques C Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C Academy ?

Aucune expérience préalable n'est requise. C Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Variables static » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C Academy ?

Oui. Chaque leçon C Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C Academy