C Academy · Leçon

extern et global

Partage entre fichiers

extern et global est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Variables globales

Une variable déclarée en dehors de toute fonction a une portée de fichier et existe pendant tout le programme. C’est une variable globale.

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

Les variables globales sont partagées

Toutes les fonctions du fichier peuvent lire et modifier une variable globale. Cela les rend pratiques, mais faciles à utiliser à mauvais escient.

#include <stdio.h>
int score = 100;
void penalty(void) { score -= 25; }
void bonus(void) { score += 10; }
int main(void) {
    penalty();
    bonus();
    printf("score = %d\n", score);
    return 0;
}

Initialisation à zéro par défaut

Les variables globales sans initialiseur commencent automatiquement à 0.

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

Le mot-clé externe

extern déclare une variable globale qui est définie ailleurs. Il indique au compilateur que la variable existe sans lui allouer d’espace.

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

Déclaration et définition

Une définition alloue un espace de stockage. Une déclaration donne simplement un nom à quelque chose. Les déclarations extern n’allouent pas d’espace.

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

Partage entre plusieurs fichiers

Dans les projets composés de plusieurs fichiers, un fichier .c définit la variable globale et les autres fichiers utilisent extern dans un fichier d’en-tête pour y accéder.

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

Les fonctions peuvent aussi être externes

Les fonctions ont une liaison externe par défaut. Un prototype constitue donc en pratique une déclaration extern de cette fonction.

#include <stdio.h>
extern void hello(void);
void hello(void) {
    printf("Hello from extern\n");
}
int main(void) {
    hello();
    return 0;
}

Durée de vie des variables globales

Les variables globales existent du début à la fin du programme. Leurs valeurs persistent donc entre tous les appels de fonction.

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

Risques des variables globales

Puisque n’importe quel code peut modifier une variable globale, les bogues deviennent difficiles à suivre. Dans la mesure du possible, préférez transmettre les valeurs comme paramètres.

#include <stdio.h>
int config = 1;
int compute(int input) {
    return input * config;
}
int main(void) {
    printf("%d\n", compute(8));
    return 0;
}

Variables globales en lecture seule

Combinez const avec une variable globale pour créer une constante partagée que personne ne peut modifier.

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

Schéma pratique

Une valeur de configuration globale lue par plusieurs fonctions constitue une utilisation courante et acceptable.

#include <stdio.h>
int multiplier = 3;
int scale(int x) { return x * multiplier; }
int main(void) {
    printf("%d\n", scale(4));
    printf("%d\n", scale(7));
    return 0;
}

Vérification rapide

Vérifiez votre compréhension des variables externes et globales.

Récapitulatif : variables externes et globales

Vous avez découvert les variables globales et la liaison externe.

Les variables globales ont une portée de fichier et une durée de vie égale à celle du programme
Elles valent 0 par défaut et sont partagées par toutes les fonctions
extern déclare une variable globale définie ailleurs
La définition alloue de l’espace, tandis que la déclaration donne seulement un nom
Utilisez les variables globales avec modération pour éviter les dépendances cachées

Questions Fréquemment Posées

La leçon « extern et global » est-elle gratuite ?

Oui — le texte complet de « extern et global » 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 « extern et global » ?

Partage entre fichiers 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 3 sur 4.

Combien de temps prend la leçon « extern et global » ?

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