C Academy · Leçon

Fichiers d’en-tête et source

Séparez les déclarations et le code.

Fichiers d’en-tête et source est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 1 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 répartir le code dans plusieurs fichiers ?

À mesure que les programmes C grandissent, conserver tout le code dans un seul fichier .c devient difficile à lire et ralentit la compilation.

Le C vous permet de répartir un projet dans plusieurs fichiers : chacun prend en charge une responsabilité. Cela améliore l'organisation, permet de réutiliser le code et évite de devoir tout recompiler lorsqu'une seule partie est modifiée.

Deux types de fichiers

Un projet C modulaire utilise deux types de fichiers.

Les fichiers source (.c) contiennent l'implémentation réelle : les corps et les définitions des fonctions.

Les fichiers d'en-tête (.h) contiennent les déclarations : les prototypes de fonctions, les définitions de types et les macros que les autres fichiers doivent connaître.

Un fichier d'en-tête

Un fichier d'en-tête déclare ce qui existe sans expliquer comment cela fonctionne.

Ici, math_utils.h déclare une fonction add. Tout fichier qui inclut cet en-tête connaît la signature de la fonction et peut l'appeler.

/* math_utils.h */
int add(int a, int b);

Le fichier source associé

Le fichier source fournit l'implémentation. Il inclut son propre en-tête afin que le compilateur puisse vérifier que la définition correspond à la déclaration.

Remarquez que l'en-tête est inclus entre guillemets, ce qui s'utilise pour les fichiers de votre propre projet.

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

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

Utiliser le module

À présent, main.c inclut l'en-tête et appelle add. Il ne voit jamais le corps de la fonction, seulement le prototype.

Le compilateur fait confiance à la déclaration ; l'éditeur de liens relie ensuite l'appel à l'implémentation réelle dans math_utils.c.

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

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

Guillemets ou chevrons

La directive #include possède deux formes.

#include <stdio.h> utilise des chevrons pour les en-têtes du système et de la bibliothèque standard. Le compilateur recherche dans ses chemins d'inclusion standard.

#include "math_utils.h" utilise des guillemets pour vos propres en-têtes, recherchés en premier dans le répertoire courant.

#include <stdio.h>      /* standard library */
#include "math_utils.h" /* your project */

Ce qui doit figurer dans un en-tête

Placez les déclarations dans les en-têtes, et non les définitions.

Un bon en-tête contient notamment des prototypes de fonctions, des déclarations struct et typedef, des macros #define et des déclarations de variables extern.

Évitez d'y placer des corps de fonctions ou des définitions de variables, car cela peut provoquer des erreurs de symboles dupliqués.

/* shapes.h */
typedef struct {
    double width;
    double height;
} Rect;

double rect_area(Rect r);

Ce qui doit figurer dans un fichier source

Le fichier source contient le travail réel : les définitions des fonctions et les utilitaires privés du fichier.

Il inclut l'en-tête associé afin que le compilateur vérifie la correspondance des signatures. Cela détecte rapidement les incohérences, plutôt qu'au moment de l'édition des liens.

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

double rect_area(Rect r) {
    return r.width * r.height;
}

Déclaration ou définition

Cette distinction est fondamentale en C modulaire.

Une déclaration indique au compilateur le type et la signature d'un nom afin qu'il puisse être utilisé : int add(int, int);

Une définition crée l'entité réelle, en allouant un espace de stockage ou en fournissant le corps. Les en-têtes déclarent ; les fichiers source définissent.

int add(int a, int b);          /* declaration */
int add(int a, int b) {         /* definition */
    return a + b;
}

Conventions de nommage

Une convention courante consiste à associer chaque module par son nom : logger.h avec logger.c, parser.h avec parser.c.

Cela indique clairement où se trouve une implémentation. Regroupez les fonctions liées dans un même module afin que chaque fichier ait une responsabilité unique et claire.

/* logger.h */
void log_info(const char *msg);
void log_error(const char *msg);

Vue d'ensemble de la compilation

Chaque fichier .c est compilé indépendamment en fichier objet, puis tous les fichiers objets sont liés pour former un seul programme.

Les en-têtes ne sont pas compilés seuls ; ils sont insérés textuellement dans les fichiers source qui les incluent. Nous étudierons le processus complet de compilation dans une leçon ultérieure.

gcc -c main.c        /* -> main.o */
gcc -c math_utils.c  /* -> math_utils.o */
gcc main.o math_utils.o -o app

Vérification rapide

Vérifiez votre compréhension du rôle des en-têtes et des fichiers source.

Récapitulatif

Vous avez appris à répartir un projet C entre des en-têtes .h et des fichiers source .c.

Les en-têtes déclarent ce qui existe ; les fichiers source définissent son fonctionnement. Utilisez les guillemets pour vos propres en-têtes et les chevrons pour les en-têtes standard.

Nous allons maintenant éviter les problèmes causés par l'inclusion répétée d'un en-tête.

Questions Fréquemment Posées

La leçon « Fichiers d’en-tête et source » est-elle gratuite ?

Oui — le texte complet de « Fichiers d’en-tête et source » 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 « Fichiers d’en-tête et source » ?

Séparez les déclarations et le code. 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 1 sur 4.

Combien de temps prend la leçon « Fichiers d’en-tête et source » ?

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