Réponse.

Le processus de compilation d'un programme C consiste en plusieurs étapes : prétraitement (preprocessing), compilation (compilation), assemblage (assembling), édition de liens (linking). Historiquement, ce schéma permettait de répartir les responsabilités entre les outils et de faciliter la maintenance et la configuration du processus de construction.

Problème : Si l'on ne comprend pas comment fonctionne chaque étape, on peut rencontrer des erreurs telles que "référence indéfinie", duplication de code, bugs non évidents dus à une mauvaise utilisation des macros, et problèmes lors de la mise à l'échelle du code sur plusieurs fichiers.

Solution : Il est nécessaire de comprendre que chaque étape remplit une fonction spécifique : le préprocesseur traite les directives #define, #include et d'autres, le compilateur traduit le code source C en assembleur, l'assembleur en code machine, et l'éditeur de liens combine tous les fichiers objets et bibliothèques en un fichier exécutable final.

Exemple de code :

Un extrait de code source :

#include <stdio.h>
#define PI 3.14

int main() {
    printf("%f
", PI);
    return 0;
}

Exemple d'appel gcc avec des étapes explicites :

gcc -E program.c       # Prétraitement
gcc -S program.c       # Compilation (jusqu'à l'assembleur)
gcc -c program.c       # Assemblage (jusqu'au fichier objet)
gcc program.o -o prog  # Édition de liens (linking)

Caractéristiques clés :

Permet de construire de grands projets à partir de modules distincts.
Facilite la réutilisation du code et l'intégration de bibliothèques.
Les erreurs liées à l'absence de fonctions/symboles apparaissent uniquement à l'étape de l'édition de liens.

Questions pièges.

Que fait la directive #include "file.h" pendant la compilation ?

#Include insère le contenu du fichier directement à l'emplacement de l'appel au stade du prétraitement, avant le début de la compilation. Si le même fichier est inclus plusieurs fois, cela peut entraîner des définitions multiples d'objets ou des erreurs lors de l'édition de liens.

Est-il toujours suffisant de définir une fonction dans un fichier pour l'utiliser dans un autre ?

Non, il est nécessaire d'avoir une déclaration (prototype) dans un fichier d'en-tête ou au moins une déclaration extern. Sinon, il peut y avoir des erreurs telles que "déclaration implicite de fonction" ou "référence indéfinie" lors de l'édition de liens.

Peut-on utiliser des variables déclarées comme static d'un autre fichier ?

Non. static limite la portée de la variable ou de la fonction au fichier en cours. Cela signifie que ces symboles ne sont pas visibles pour l'éditeur de liens dans d'autres fichiers objets.

Erreurs typiques et anti-patterns

Oubli d'inclure une protection contre les inclusions multiples (#ifndef/#define/#endif) dans les fichiers d'en-tête.
Tenter de définir la même fonction dans plusieurs fichiers.
Mauvaise utilisation de static/extern.

Exemple de la vie réelle

Cas négatif

Un débutant met en œuvre une fonction avec le même nom dans deux fichiers source. À l'étape de l'édition de liens, une étrange erreur "définition multiple de fonction" se produit.

Avantages :

Simplicité : il est possible de développer rapidement le code sans structurer les projets.

Inconvénients :

Débogage difficile des erreurs d'édition de liens, absence de clarté sur la cause des problèmes rencontrés.
Le projet est difficile à mettre à l'échelle.

Cas positif

Création de fichiers .h uniquement pour les déclarations, de fichiers .c pour les définitions. Utilisation de #ifdef pour protéger les fichiers d'en-tête. Tous les fichiers sont reliés par l'éditeur de liens dans le programme final.