.. role:: bash(code)
   :language: bash

Fichiers d'include
##################

Afin de mieux organiser votre code, il est possible de travailler avec plusieurs fichiers sources.
Aussi, cela permet de ne recompiler que les sources qui ont été modifiés.

Nous allons commencer avec un exemple tout simple. Puis au fur et à mesure vous allez 
trouver les indications nécessaires pour construire des objets autres que des exécutables tels qu'une 
librairie système ou une bibliothèque partagée.

Ceci permet par exemple de créer un fichier source contenant des fonctions pouvant être utilisées 
par plusieurs programmes. Cela permet de simplifier la maintenance des programmes.

Mais, avant tout, regardons comment cela fonctionne, comment utiliser le compilateur gcc pour compiler 
un code source C composé de plusieurs fichiers sources.

Exemple
=======

Voici un premier exemple pour commencer. Il est composé de trois fichiers sources C:

* prog.c: fichier source principal contenant la fonction *main()*.
* func.c: fichier source secondaire contenant une fonction appelée par *main()*
* func.h: fichier d'en-tête qui sera inclus dans le fichier *prog.c*

L'image ci-dessous donne un aperçu de la manière dont sera compilé le fichier:

.. image:: ./images/include_illustration01.png
   :align: center

Pour commencer, nous allons d'abord compiler les fichiers sources C en objets. 

La commande :bash:`gcc -c prog.c -o prog.o` permet de compiler le code source *prog.c* en objet.
De même :bash:`gcc -c func.c -o func.o` génèrera l'objet *func.o*.

Ces deux fichiers objets seront liés par commande :bash:`gcc func.o prog.o -o prog` pour 
construire le fichier exécutable *prog*.

Sources
=======

Pour commencer voici le fichier *func.c*:

.. literalinclude:: ./sources/include/func.c
   :language: c
   :linenos:

Ce fichier contient une fonction toute simple **say_hello()** qui sera appelée dans le programme principal *prog*.
Il peut être immédiatement compilé en objet avec la commande :bash:`gcc -c func.c -o func.o`.

Le fichier contenant le programme principal *prog.c*:

.. literalinclude:: ./sources/include/prog.c
   :language: c
   :linenos:

A noter, que la ligne 5 contient une instruction particulière :code:`#include "func.h"` qui va inclure 
le fichier *func.h* ci-dessous:

.. literalinclude:: ./sources/include/func.h
   :language: c
   :linenos:

En fait, c'est le précompilateur qui va se charger d'inclure le fichier *func.h* dans *prog.c*.
La commande :bash:`gcc -E prog.c -o prog.i` permet de mieux comprendre. En fait, elle demande à **gcc** de 
générer le résultat de la pré-compilation dans le fichier *prog.i*. 

.. literalinclude:: ./sources/include/prog.i
   :language: c
   :linenos:

On comprend maintenant que le fichier *prog.c* est transformé avant la compilation afin que celui-ci contienne
la déclaration de la fonction *say_hello()* afin de signaler au compilateur que le code de *prog.c* fait
appel à une fonction dont le code est situé ailleurs. Le compilateur va en tenir compte lors de la construction
de l'objet *prog.o*.

Maintenant, il ne reste plus qu'à assembler les objets *prog.o* et *func.o* avec la commande
:bash:`gcc prog.o func.o -o prog`.

Voilà, vous savez maintenant comment faire pour écrire vos programmes en plusieurs fichiers.

En complément, voici le contenu du fichier **Makefile**:

.. literalinclude:: ./sources/include/Makefile
   :language: make
   :linenos: