.. _Compiler_avec_gcc:

Compiler avec gcc
#################

Le but de cet article est de vous familiariser avec le compilateur
GNU C, **gcc**.  Il concentre les options et les constructions de la ligne de commande qui sont spécifiques à **gcc**.

Il explique:

* comment dire à **gcc** quel dialecte du C il doit s'attendre à rencontrer 
* quelles variétés de constructions à usage spécifique sont soutenues par **gcc**
* comment les invoquer et les utiliser

Interprétation des options
==========================

Le compilateur **gcc** accepte à la fois les options à une seule lettre (eg. *-c*, *-p*...), et les options à plusieurs lettres (eg. *-ansi*, *-shared*...). 
Comme il accepte les deux types d'options, vous ne pouvez pas regrouper plusieurs options à une seule lettre comme vous pouvez en avoir l'habitude avec les
nombreux programmes GNU et Unix/Linux. 

Par exemple, l'option multilettre *-pg* n'est pas la même que les deux 
options à une lettre *-p -g*. 
En effet, l'option *-pg* crée un code supplémentaire dans le binaire final
qui produit des informations de profil pour le profileur de code GNU, *gprof*. 
Et, les options *-p -g* génèrent un code supplémentaire dans le binaire 
résultant qui produit des informations de profilage destinées à être
utilisées par le profileur de code *prof* (-p) et fait en sorte que 
**gcc** génère des informations de débogage en utilisant le format normal
du système d'information (*-g*).

vous êtes, de manière générale, libre de mélanger l'ordre des options 
et de compiler les arguments car dans dans la plupart des cas, l'ordre
des options et leurs arguments n'ont pas d'importance. 

Il peut être important lors de l'utilisation de plusieurs options 
du même type. Par exemple, l'option *-I* spécifie le répertoire
ou les répertoires où rechercher des fichiers d'inclusion. Ainsi, 
si vous spécifiez *-I* plusieurs fois, **gcc** recherche les fichiers
dans l'ordre indiqué.

Compilation des dialectes C
===========================

Le compilateur gcc supporte une variété de dialectes du C via une 
série d'options en ligne de commande qui permettent à la fois des
caractéristiques uniques et des gammes de caractéristiques spécifiques
à des variantes particulières du langage C.

La raison la plus courante de compiler un code pour un dialecte
spécifique du C est la portabilité. Si vous souhaitez écrire un code
compilable par des outils différents, vous pouvez vérifier si ce code
est respecté.
La vérification de l'adhésion à diverses normes est l'une des méthodes
utilisées par les développeurs pour réduire le risque de se retrouver
à court de temps faute de problèmes de compilation et d'exécution lorsque
le code est déplacé d'une plate-forme à une autre, en particulier lorsque
qu'une plateforme cible n'a pas été prise en compte lors de la rédaction
initiale du programme.

Pour commencer
==============

Afin de commencer avec un exemple simple, voici comment compiler un programme C
composé d'un fichier source unique nommé **exemple.c** pour obtenir un exécutable 
nommé **a.out**:

.. code-block:: sh

   $ gcc exemple.c

Toujours avec le même source, mais cette fois-ci pour obtenir un exécutable nommé
**exemple**:

.. code-block:: sh

   $ gcc exemple.c -o exemple

Vérifier la conformité du code
==============================

En C il est possible d'écrire des programmes pas tout à fait conformes, mais qui
se compilent quand même et peuvent avoir un comportement non souhaité, voir compromettre
la sécurité du système. Afin d'avoir quelques retour du compilateur sous forme de 
warning, utiliser les options **-Wall** et **-Wextra** comme ceci:

.. code-block:: sh

   $ gcc exemple.c -o exemple -Wall -Wextra

Ces options permettent d'activer tous les warnings lors de la compilation. Si on le
souhaite, il est possible d'ajouter l'option **-Werror** pour transformer les alertes
(warnings) en erreur critique:

.. code-block:: sh

   $ gcc exemple.c -o exemple -Wall -Wextra -Werror

Options de gcc par défaut
=========================

Selon la distribution utilisée **gcc** utilise des options par défaut. 
Un moyen simple de les lister est d'utiliser la commande:

.. code-block:: sh

   $ gcc -Q --help=target