Le langage C
Partie 3 sur 3
6Le préprocesseur
6.1Inclure les fichiers d’en-tête
Dans le premier programme, la fonction main() appelle la fonction printf(). En réalité, le compilateur ne connaît pas printf(), bien qu’il s’agisse d’une fonction standard du C. Il faut lui indiquer, avant tout appel, comment elle s’utilise : son nom, ses paramètres, le type de son résultat. Cette déclaration, ou prototype, se trouve dans un fichier annexe, appelé fichier d’en-tête (en anglais header), dont l’extension est .h. Celle de printf() se trouve dans stdio.h ; stdio signifie Standard Input Output, entrées-sorties standard : ce fichier déclare de nombreuses fonctions d’entrée, comme la saisie au clavier, et de sortie, comme l’affichage ou l’écriture dans un fichier.
Le fichier d’en-tête est souvent présenté comme un « fichier de définition » contenant « une librairie de fonctions ». Il faut distinguer deux choses : le fichier d’en-tête ne contient que les déclarations, qui décrivent comment appeler les fonctions ; leur définition, c’est-à-dire leur code, se trouve dans la bibliothèque standard, déjà compilée, que l’éditeur de liens associe au programme à la fin de la compilation (section 6.4).
L’inclusion se fait au moyen de la directive #include, placée en début de fichier, suivie du nom du fichier entre les signes < et > pour les en-têtes du système, ou entre guillemets pour les fichiers d’en-tête du projet lui-même :
#include <stdio.h> /* en-tête standard, cherché dans les dossiers du système */ #include "calculs.h" /* en-tête du projet, cherché d'abord dans le dossier courant */
La directive doit se trouver avant toute utilisation des fonctions déclarées. Autrefois, son absence provoquait au minimum un avertissement ; depuis la norme de 1999, appeler une fonction non déclarée est une erreur, que les compilateurs récents refusent par défaut. Point important : les instructions destinées au préprocesseur, qui commencent toutes par le caractère #, ne se terminent pas par un point-virgule.
6.2Les constantes et les macros
La directive #define associe un nom à un texte, que le préprocesseur substitue partout où le nom apparaît :
#define TAILLE_MAX 100 #define CARRE(x) ((x) * (x)) char nom[TAILLE_MAX]; int aire = CARRE(cote);
La première ligne définit une constante ; la seconde, une macro avec paramètre. Le préprocesseur procède par simple remplacement de texte, sans rien comprendre au langage, d’où des pièges célèbres : sans les parenthèses, CARRE(2 + 3) deviendrait 2 + 3 * 2 + 3, soit 11 au lieu de 25 (exercice 2). Le C moderne préfère, quand c’est possible, de vraies constantes typées et des fonctions.
6.3La compilation conditionnelle
Les directives #if, #ifdef, #ifndef, #else et #endif permettent de garder ou d’écarter des parties du code avant la compilation, par exemple pour adapter un programme à Windows ou à Linux, ou pour ajouter des messages de débogage dans une version de test seulement. Elles servent aussi à éviter qu’un fichier d’en-tête soit inclus deux fois, grâce à une garde d’inclusion :
#ifndef CALCULS_H #define CALCULS_H int somme(int a, int b); #endif
6.4Les étapes de la compilation
La compilation se fait en plusieurs phases : le compilateur transforme le code source en code objet, en passant parfois par un fichier en assembleur, puis l’éditeur de liens (en anglais linker ou binder) intègre les éléments annexes, fonctions et bibliothèques, auxquels le programme fait référence, pour produire un exécutable autonome. Dans le cas du C, une phase supplémentaire intervient en premier : le traitement du fichier par le préprocesseur, qui inclut les éléments référencés par les directives commençant par #. Les étapes sont donc les suivantes (figure 1, et voir la compilation) :
- le préprocesseur traite les directives et produit un code source développé ;
- le compilateur proprement dit le traduit en assembleur ;
- l’assembleur produit un fichier objet, en langage machine ;
- l’éditeur de liens rassemble les fichiers objets du programme et le code des bibliothèques, comme celui de
printf(), et produit l’exécutable.
Pour s’exercer
Exercice 1 : trouver les erreurs
Ce programme ne compile pas. Trouvez les quatre erreurs : #include <stdio.h>;, puis int Main(void), puis { Printf("Bonjour\n") return 0; }.
Voir la réponse
1) La directive #include ne doit pas se terminer par un point-virgule. 2) La fonction principale doit s’appeler main, en minuscules : le C est sensible à la casse, et l’éditeur de liens ne trouvera pas de fonction main. 3) Printf doit s’écrire printf. 4) Il manque le point-virgule à la fin de l’instruction printf(...). Version correcte : #include <stdio.h>, int main(void), { printf("Bonjour\n"); return 0; }.
Exercice 2 : le piège des macros
On définit #define CARRE(x) x * x. Que valent CARRE(4), CARRE(2 + 3) et 100 / CARRE(5) ? Comment corriger la macro ?
Voir la réponse
Le préprocesseur remplace le texte sans calculer. CARRE(4) devient 4 * 4 = 16, correct. CARRE(2 + 3) devient 2 + 3 * 2 + 3 = 11, au lieu de 25. 100 / CARRE(5) devient 100 / 5 * 5 = 100, au lieu de 4. La correction consiste à parenthéser chaque paramètre et le résultat : #define CARRE(x) ((x) * (x)). Il reste un piège : CARRE(i++) incrémente i deux fois. Une fonction ordinaire, éventuellement déclarée inline, est plus sûre.
7Les notions essentielles, en bref
Chacune des notions suivantes fait l’objet d’un article détaillé ; cette section en donne l’essentiel, pour lire un programme C.
7.1Types et variables
Toute variable doit être déclarée avec son type avant d’être utilisée. Les types de base sont peu nombreux : char, un octet, pour un caractère ou un petit entier ; int, un entier, le plus souvent sur 4 octets ; long et long long pour les grands entiers ; float et double pour les nombres à virgule. Leur taille exacte dépend de la machine et du compilateur, ce qui est un piège de portabilité ; l’opérateur sizeof la donne en octets, et l’en-tête stdint.h fournit des types de taille garantie, comme int32_t. Les entiers peuvent être signés ou non signés (unsigned), ce qui change leur plage de valeurs (exercice 3 ; voir les variables et les types).
int age = 42; double prix = 19.90; char initiale = 'M'; unsigned char octet = 255;
7.2Opérateurs, conditions et boucles
Le C fournit les opérateurs arithmétiques, de comparaison, logiques et de bits présentés dans l’article sur les langages (voir les opérateurs), et les structures de contrôle classiques : if et else, switch, les boucles while, do … while et for (voir les structures conditionnelles). Particularité historique : le C n’avait pas de type booléen à l’origine ; une valeur nulle signifie « faux », toute autre « vrai ».
for (int i = 1; i <= 10; i++) {
if (i % 2 == 0) {
printf("%d est pair\n", i);
}
}
7.3Fonctions
Un programme C est un ensemble de fonctions, dont main(). Chaque fonction est déclarée avec le type de son résultat et de ses paramètres. Les paramètres sont transmis par valeur : la fonction reçoit une copie, et ne peut modifier la variable d’origine qu’à condition de recevoir son adresse, par un pointeur (voir les fonctions).
int somme(int a, int b)
{
return a + b;
}
7.4Tableaux et chaînes de caractères
Un tableau est une suite de cases du même type, rangées côte à côte en mémoire et numérotées à partir de 0 : int notes[5] réserve cinq entiers, de notes[0] à notes[4]. Le C ne vérifie pas que l’indice reste dans les limites : notes[5] désigne la case qui suit le tableau, qui appartient peut-être à une autre variable. Une chaîne de caractères est un tableau de char terminé par le caractère nul, noté '\0', qui en marque la fin : la chaîne « Momo » occupe donc 5 octets (voir les chaînes de caractères). Les structures, enfin, regroupent plusieurs variables de types différents sous un même nom, comme les champs d’une fiche (voir les structures de données).
7.5Pointeurs et mémoire
La mémoire est une longue suite de cases numérotées, chacune d’un octet ; le numéro d’une case est son adresse (voir la mémoire vive). Un pointeur est une variable qui contient l’adresse d’une autre donnée (figure 2). L’opérateur & donne l’adresse d’une variable, et l’opérateur * permet d’accéder à la donnée pointée. Les pointeurs servent partout en C : à modifier une variable depuis une fonction, à parcourir un tableau, à construire des structures de données comme les listes chaînées, et à gérer la mémoire allouée pendant l’exécution, réservée par malloc() et libérée par free(), sans aucune aide automatique (voir la mémoire et les pointeurs).
Cette liberté est à double tranchant. Utiliser une zone de mémoire après l’avoir libérée, la libérer deux fois, oublier de la libérer, écrire au-delà de la zone réservée, suivre un pointeur nul ou non initialisé : autant d’erreurs que le compilateur ne détecte pas, et qui provoquent plantages, fuites de mémoire ou failles de sécurité (figure 3 et coin cyber).
Pour s’exercer
Exercice 3 : les limites des entiers
Sur une machine où int occupe 4 octets, quelles sont les plages de valeurs d’un unsigned char, d’un int et d’un unsigned int ? Que se passe-t-il si l’on ajoute 1 à un unsigned char qui vaut 255 ?
Voir la réponse
Un unsigned char tient sur 8 bits : de 0 à 28 − 1 = 255. Un int de 32 bits signé va de −231 = −2 147 483 648 à 231 − 1 = 2 147 483 647 ; un unsigned int de 0 à 232 − 1 = 4 294 967 295 (voir le binaire). Ajouter 1 à un unsigned char valant 255 donne 0 : le calcul « fait le tour » du compteur. Pour un entier signé, le dépassement est un comportement indéfini. Ces débordements d’entiers sont une cause classique de failles, par exemple quand un calcul de taille trop grande « fait le tour » et réserve une zone de mémoire minuscule.
Exercice 4 : la place d’une chaîne
Un programme déclare char nom[8]; pour stocker un prénom. Combien de caractères peut-il contenir au plus ? Que se passe-t-il si l’on y copie « Christophe » sans vérifier la longueur ?
Voir la réponse
Il faut une case pour le caractère nul final : 7 caractères au plus. « Christophe » compte 10 lettres, soit 11 octets avec le caractère nul : 3 octets sont écrits au-delà du tableau, sur ce qui se trouve à côté en mémoire (figure 3). Selon le cas, rien de visible, un plantage, ou la modification d’une autre variable, voire, si un attaquant contrôle le contenu, le détournement du programme. Il faut toujours limiter la copie à la taille du tableau, par exemple avec snprintf(nom, sizeof nom, "%s", saisie) ou fgets() pour une saisie.
Exercice 5 : suivre des pointeurs
Que valent a et b à la fin de ce code : int a = 5, b = 8; int *p = &a; *p = *p + b; p = &b; *p = 0; ?
Voir la réponse
p pointe d’abord sur a : *p = *p + b range dans a la valeur 5 + 8 = 13. Puis p pointe sur b, et *p = 0 met b à 0. À la fin, a vaut 13 et b vaut 0. On remarque que a et b ont été modifiées sans être jamais nommées à gauche d’une affectation : c’est toute la puissance, et la difficulté de relecture, des pointeurs.
Exercice 6 : observer les étapes
Avec GCC, quelles commandes permettent de voir le résultat du préprocesseur, puis l’assembleur produit, à partir de premier.c ? Que constate-t-on dans le premier fichier ?
Voir la réponse
gcc -E premier.c -o premier.i s’arrête après le préprocesseur ; gcc -S premier.c produit premier.s, en assembleur. Dans premier.i, on constate que les quelques lignes du programme sont précédées de centaines de lignes : ce sont les déclarations de stdio.h et des fichiers qu’il inclut lui-même, dont celle de printf. Les commentaires ont disparu, et les macros ont été remplacées par leur texte.