La conversion d’un fichier source C en un programme exécutable s’effectue en plusieurs étapes, chacune pouvant être déclenchée individuellement via l’outil gcc.

• Prétratiement (gcc -E source.c) :
  • Développement des fichiers inclus via #include
  • Suppression des commentaires
  • Substitution des constantes et macros
  • Gestion des sections conditionnelles avecc #if, #ifdef, etc.
• Compilation (gcc -S source.c) : Génération d’un fichier assembleur (.s) à partir du code sourceC. Le compilateur vérifie également la syntaxe.
• Assemblage (gcc -c source.c) : Conversion du code assembleur en instructions binaires (objet, .o ou .obj).
• Édition des liens : Fusion de plusieurs fichiers objets et resolution des références vers les bibliothèques (statiques ou partagées).

Ces quatre étapes peuvent être effectuées en une seule commande : gcc source.c -o programme.

2. Fonction main()

Point d’entrée obligatoire de tout programme C. Le programme débute son exécution à partir de cette fonction.

• Symbole unique : chaque executable ne peut contenir qu’une seule définition de main().

• Signature possible : ``` // Forme sans arguments int main(void) { return 0; }

  // Forme avec arguments int main(int nb_args, char *tableau_args[]) { // nb_args : nombre de paramètres passés // tableau_args[] : liste des chaînes de caractères passées en ligne de commande return 0; }

  
   </div>
  
  

3. Fichiers d’en-tête

Les fichiers .h contiennent les déclarations nécessaires à la compilation : signatures de focntions, définitions de types, constantes, structures partagées, etc.

• Inclusion standard : #include <nom.h> → recherche dans les répertoires système.
• Inclusion locale : #include "mon_module.h" → recherche d’abord dans le répertoire courant.

Les en-têtes facilitent :

• La modularité et la réutilisabilité du code
• Les compilations incrémentales
• La séparation entre interface et implémentation
• La prévention des redéfinitions via les include guards

Bibliothèques standard courantes

4. Compilation multi-fichiers

Lorsqu’un projet utilise plusieurs fichiers sources (.c), deux_approches sont possibles :

• Compilation directe : gcc precedent.c courant.c -o prog_final
• Compilation séparée + édition des liens (recommandée pour les projets volumineux) : gcc -c precedent.c -o precedent.o
gcc -c courant.c -o courant.o
gcc precedent.o courant.o -o prog_final

5. Conventions de style etbonnes pratiques

• Indentation : utiliser systématiquement une indentation cohérente (généralement 4 espaces)

• Nommage :

  • Valeurs variables : nb_essais
  • Fonctions : verbe + complément (calculer_moyenne)
  • Constantes : majuscules séparées par des tirets bas (TAILLE_MAX)

• Définitions de fonctions :

  • Déclarations dans les fichiers .h
  • Définitions dans les fichiers .c
  • Prototypes cohérents entre les deux

• Gestion des erreurs : ``` #include <stdio.h> #include <stdlib.h>

  int traiter_donnees() { // Simule un traitement pouvant échouer return -1; }

  int main(void) { int ret = traiter_donnees(); if (ret < 0) { perror("traiter_donnees"); exit(EXIT_FAILURE); } return 0; }

  
   </div>
  

• Mémoire dynamique : chaque appel à malloc, calloc ou realloc doit être apparié à un freeWould-be-escaped double-quote.

• Include guards (prévention des inclusions multiples) : ``` #ifndef MON_MODULE_H #define MON_MODULE_H

  // Déclarations...

  #endif // MON_MODULE_H

  
   </div>
  
  

6. Commentaires

• Ligne unique : // texte explicatif
• Blocs : /* multiple<br></br>lignes */
  L’usage des commentaires doit rester modéré : le code doit rester le plus explicite possible.