Aller au contenu
Encyclopédie informatique Édition 2026

Le langage C

Partie 3 sur 3

Niveau de lecture :

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) :

  1. le préprocesseur traite les directives et produit un code source développé ;
  2. le compilateur proprement dit le traduit en assembleur ;
  3. l’assembleur produit un fichier objet, en langage machine ;
  4. 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.
premier.c code source premier.i source développé premier.s assembleur premier.o code objet préprocesseur gcc -E compilateur gcc -S assembleur gcc -c éditeur de liens gcc -o premier bibliothèque standard code de printf()… premier exécutable #include insère les déclarations de stdio.h ; #define remplace les macros par leur texte. Une seule commande, gcc -o premier premier.c, enchaîne toutes ces étapes.
Figure 1. Les étapes de la compilation d’un programme C avec GCC ; les options indiquées permettent de s’arrêter après chaque étape.

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).

LA MÉMOIRE, UNE SUITE DE CASES NUMÉROTÉES 42 0x1000 age 0x1004 … 0x1000 0x1008 p 0x1010 … p contient l’adresse de age : on dit que p « pointe » sur age int age = 42; int *p = &age; /* p reçoit l’adresse de age */ *p = 43; /* modifie age à travers p */
Figure 2. Un pointeur contient une adresse. Les adresses sont des exemples ; sur une machine 64 bits, un pointeur occupe 8 octets.

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.

Sécurité de l’information

Le coin cyber

Le C est partout où la sécurité se joue : systèmes d’exploitation, réseaux, chiffrement, objets connectés. Et c’est le langage où les erreurs de mémoire se transforment le plus facilement en failles exploitables. Les attaques sont décrites ici dans leur principe seulement.

C.1Le débordement de tampon

Un débordement de tampon (en anglais buffer overflow) se produit quand un programme écrit plus de données qu’une zone de mémoire, le tampon, ne peut en contenir : les octets en trop écrasent ce qui se trouve à côté (figure 3). Si la donnée écrasée est une autre variable, le programme se comporte de travers ; si c’est une information qui indique au processeur où poursuivre l’exécution, et si l’attaquant contrôle les données copiées, il peut détourner le programme pour lui faire exécuter ses propres instructions (voir le débordement de tampon). Le ver de Morris en 1988, puis d’innombrables attaques depuis, ont exploité ce mécanisme. Des fonctions de la bibliothèque standard qui ne vérifient pas les longueurs, comme gets(), strcpy() ou sprintf(), en sont la source classique.

char nom[8]; int est_admin = 0; (disposition simplifiée de la mémoire) Saisie « Momo » (4 lettres + fin \0) : tout tient dans les 8 cases M 0 o 1 m 2 o 3 \0 4 ? 5 ? 6 ? 7 0 0 0 0 est_admin = 0 Saisie « Christophe » sans vérification de longueur : 11 octets écrits dans 8 cases C h r i s t o p h e \0 0 est_admin n’est plus 0 : « vrai » ! Les octets en trop débordent sur la variable voisine. La disposition réelle dépend du compilateur ; le principe reste le même.
Figure 3. Le principe du débordement de tampon : sans vérification de longueur, une saisie trop longue écrase la variable voisine.

C.2Les autres erreurs de mémoire

La lecture hors limites est tout aussi dangereuse : en 2014, la faille Heartbleed, dans la bibliothèque de chiffrement OpenSSL écrite en C, permettait à n’importe qui sur Internet de lire jusqu’à 64 kilo-octets de la mémoire d’un serveur à chaque requête, y compris des mots de passe et des clés de chiffrement, parce que le programme faisait confiance à une longueur annoncée par l’autre partie. L’utilisation après libération, quand un programme se sert d’une zone de mémoire déjà rendue, et les erreurs de chaînes de format, quand une donnée saisie est passée telle quelle à printf(), figurent aussi parmi les causes classiques de failles. Microsoft et Google estiment qu’environ 70 % des failles graves de leurs produits viennent de ce type d’erreurs.

C.3Les défenses

Plusieurs lignes de défense se complètent. Dans le code : vérifier toutes les longueurs, utiliser les fonctions bornées (fgets(), snprintf()), suivre des règles de programmation sûres. Lors de la compilation : activer tous les avertissements, et les protections comme les « canaris » qui détectent l’écrasement de la pile, ou les versions renforcées des fonctions de la bibliothèque. Lors des tests : les outils de détection d’erreurs de mémoire comme AddressSanitizer, l’analyse statique, qui examine le code sans l’exécuter, et le fuzzing, qui bombarde le programme d’entrées aléatoires. Dans le système, enfin : la randomisation des adresses en mémoire et l’interdiction d’exécuter les données rendent l’exploitation beaucoup plus difficile. À plus long terme, les composants les plus exposés sont progressivement réécrits dans des langages sûrs pour la mémoire, comme Rust, accepté dans le noyau Linux depuis 2022 (voir le développement sécurisé).

C.4Idée reçue

« Un programme C qui compile sans erreur et qui fonctionne est correct. » Faux. Le compilateur ne vérifie ni les limites des tableaux, ni la validité des pointeurs, et un comportement indéfini peut rester invisible pendant des années, jusqu’à ce qu’une entrée inhabituelle, ou un attaquant, le déclenche. Seuls les tests poussés, les outils de détection et la relecture attentive permettent de s’en approcher.

C.5Bonnes pratiques

Apprenti programmeur

  • Compiler avec -Wall -Wextra et traiter chaque avertissement comme une erreur.
  • Ne jamais utiliser gets() ; vérifier la longueur de toute donnée copiée dans un tableau.
  • Initialiser toutes les variables et tous les pointeurs, et mettre un pointeur à NULL après l’avoir libéré.

Organisation

  • Appliquer un référentiel de programmation sûre (guide de l’ANSSI, CERT C, MISRA C pour l’embarqué).
  • Intégrer analyse statique, détection d’erreurs de mémoire et fuzzing dans la chaîne de développement.
  • Activer les protections du compilateur et du système, et étudier pour les nouveaux composants exposés un langage sûr pour la mémoire.

Référentiels : ANSSI (Agence nationale de la sécurité des systèmes d’information), Règles de programmation pour le développement sécurisé de logiciels en langage C (2020) · SEI CERT (centre de réponse aux incidents de l’université Carnegie-Mellon), C Coding Standard · MISRA (consortium de l’industrie automobile), MISRA C:2023 · norme ISO/IEC 9899:2024 (C23).

Références

  1. B. W. Kernighan, D. M. Ritchie, Le langage C : norme ANSI, 2e éd., Dunod (trad. de The C Programming Language, Prentice Hall, 1988).
  2. D. M. Ritchie, « The Development of the C Language », Second History of Programming Languages Conference, ACM, 1993.
  3. ISO/IEC 9899:2024, Information technology — Programming languages — C.
  4. R. C. Seacord, Effective C: An Introduction to Professional C Programming, No Starch Press, 2020.
  5. ANSSI, Règles de programmation pour le développement sécurisé de logiciels en langage C, guide ANSSI-PA-073, 2020.

Voir aussi

Citer cet article

« Le langage C », Encyclopédie informatique, révision du 23 octobre 2026.