C Academy · Leçon

Projets à plusieurs fichiers

En-têtes et unités de traduction

Projets à plusieurs fichiers 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.

Pourquoi séparer les fichiers

Les programmes réels ne tiennent pas dans un seul fichier .c. Répartir le code dans plusieurs fichiers :

Regroupe les fonctions liées
Permet au compilateur de ne reconstruire que ce qui a changé
Rend le code réutilisable dans plusieurs projets
Permet à une équipe de travailler sans conflits permanents

Comprendre comment ces éléments s’assemblent est essentiel.

Unités de traduction

Chaque fichier .c, après l’expansion de ses #includes par le préprocesseur, devient une unité de traduction.

Le compilateur transforme chaque unité de traduction en un fichier objet (.o) indépendamment. À cette étape, il ne connaît pas les autres fichiers.

Déclaration ou définition

Une déclaration indique au compilateur qu’une fonction existe et précise sa signature. Une définition fournit son corps réel.

Les autres fichiers n’ont besoin que de la déclaration pour appeler une fonction. La définition se trouve exactement à un seul endroit.

int add(int a, int b);          /* declaration: a promise */

int add(int a, int b) {         /* definition: the body */
    return a + b;
}

Le fichier d’en-tête

Les déclarations se placent dans un fichier d’en-tête (.h). Tout fichier qui souhaite utiliser la fonction inclut cet en-tête.

L’en-tête constitue l’interface publique ; le fichier .c correspondant contient l’implémentation privée.

/* math_utils.h */
#ifndef MATH_UTILS_H
#define MATH_UTILS_H

int add(int a, int b);
int mul(int a, int b);

#endif

Le fichier d’implémentation

Le fichier .c inclut son propre en-tête et définit les fonctions.

Inclure votre propre en-tête permet au compilateur de vérifier que les définitions correspondent aux déclarations.

/* math_utils.c */
#include "math_utils.h"

int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }

Utiliser le module

Un autre fichier inclut l’en-tête et appelle les fonctions. Il n’a jamais besoin de voir leur corps.

Le compilateur fait confiance aux déclarations ; l’éditeur de liens reliera plus tard les appels aux véritables définitions.

/* main.c */
#include <stdio.h>
#include "math_utils.h"

int main(void) {
    printf("%d\n", add(2, 3));
    return 0;
}

Compiler et établir les liens

Deux phases. Commencez par compiler chaque fichier en fichier objet avec -c. Puis liez les fichiers objets pour produire un seul exécutable.

L’éditeur de liens résout chaque appel à add en trouvant sa définition dans math_utils.o.

gcc -c main.c          # -> main.o
gcc -c math_utils.c    # -> math_utils.o
gcc main.o math_utils.o -o app

Guillemets ou chevrons

La syntaxe d’inclusion contrôle le chemin de recherche :

#include "math_utils.h" recherche d’abord dans le répertoire de votre projet
#include <stdio.h> recherche uniquement dans les chemins d’inclusion du système

Utilisez les guillemets pour vos propres en-têtes et les chevrons pour la bibliothèque standard.

Le mot-clé extern

Pour partager une variable globale entre plusieurs fichiers, définissez-la une seule fois dans un fichier .c et déclarez-la avec extern dans l’en-tête.

extern signifie « cette variable existe ailleurs », ce qui évite les définitions en double.

/* in config.h */
extern int g_verbose;   /* declaration */

/* in config.c */
int g_verbose = 0;      /* the single definition */

Le mot-clé static

À la portée du fichier, static rend une fonction ou une variable privée dans son unité de traduction.

Un utilitaire statique ne peut pas être lié depuis d’autres fichiers, ce qui empêche les collisions de noms et masque les détails d’implémentation. C’est la manière propre au C de marquer un élément comme interne.

/* visible only inside this .c file */
static int helper(int x) {
    return x * 2;
}

La règle de définition unique

Une fonction non statique ou une variable globale peut être définie exactement une fois dans l’ensemble du programme. Vous pouvez la déclarer dans plusieurs fichiers, mais vous devez la définir dans un seul.

Deux définitions de add produisent une erreur de l’éditeur de liens comme multiple definition of 'add'. C’est pourquoi les corps des fonctions ne doivent pas figurer dans les fichiers d’en-tête.

Vérification rapide

Déterminez ce qui doit figurer dans un fichier d’en-tête.

Récapitulatif

Vous pouvez maintenant structurer un projet composé de plusieurs fichiers :

Chaque .c est une unité de traduction compilée indépendamment en un fichier .o
Les fichiers d’en-tête contiennent les déclarations ; un fichier .c contient chaque définition
L’éditeur de liens résout les appels entre les fichiers objets
extern partage les variables globales ; static garde les symboles locaux au fichier privés

Ensuite : automatiser la compilation avec des Makefiles.

Questions Fréquemment Posées

La leçon « Projets à plusieurs fichiers » est-elle gratuite ?

Oui — le texte complet de « Projets à plusieurs fichiers » 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 « Projets à plusieurs fichiers » ?

En-têtes et unités de traduction 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 « Projets à plusieurs fichiers » ?

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