Pourquoi n’y a-t-il pas de point-virgule après les directives du préprocesseur?

Si j’écris

#include ; 

il n’y a pas d’erreur mais un avertissement est émis lors de la compilation

pari.c: 1: 18: avertissement: jetons supplémentaires à la fin de la directive #include

Quelle est la raison ?

La raison en est que les directives du préprocesseur n’utilisent pas de points-virgules. En effet, ils utilisent un saut de ligne pour délimiter les instructions. Cela signifie que vous ne pouvez pas avoir plusieurs directives par ligne:

 #define ABC #define DEF // illegal 

Mais vous pouvez en avoir un sur plusieurs lignes en terminant chaque ligne (sauf la dernière) par un \ (ou /, je l’oublie).

Parce que les directives de préprocesseur sont des lignes incluses dans le code de nos programmes qui ne sont pas des instructions de programme, mais des directives pour le préprocesseur.

Ces directives de préprocesseur ne s’étendent que sur une seule ligne de code. Dès qu’un caractère de nouvelle ligne est trouvé, la directive préprocesseur est considérée comme se terminant. C’est pourquoi aucun point-virgule (;) n’est attendu à la fin d’une directive du préprocesseur.

Les directives de préprocesseur sont dans un langage différent de C et ont une grammaire beaucoup plus simple, car à l’origine, elles étaient “analysées”, si vous pouvez l’appeler ainsi, par un programme différent appelé cpp avant que le compilateur C ne voie le fichier. Les gens pourraient l’utiliser pour prétraiter même des fichiers non-C afin d’inclure des parties conditionnelles de fichiers de configuration, etc.

Il existe un programme Linux appelé “unifdef” que vous pouvez toujours utiliser pour supprimer certaines parties conditionnelles d’un programme si vous savez qu’elles ne seront jamais vraies. Par exemple, si vous avez du code pour prendre en charge des compilateurs standard non-ANSI entourés de #ifdef ANSI/#else/#end ou simplement #ifndef ANSI/#end , et que vous savez que vous ne supporterez plus jamais de non-ANSI. , vous pouvez éliminer le code mort en l’exécutant avec unifdef -DANSI .

Parce qu’ils sont inutiles. Les directives de préprocesseur n’existent que sur une ligne, à moins que vous n’utilisiez explicitement un caractère de continuation de ligne (par exemple, une grosse macro).

et si vous utilisez #define MACRO(para) fun(para); il pourrait être FAUX de mettre un semikolon derrière.

 if (cond) MACRO (par1); else MACRO (par2); 

conduit à une erreur syntaxique

Lors de la compilation, votre code est traité par deux programmes distincts, le pré-processeur et le compilateur. Le pré-processeur s’exécute en premier.

Votre code est en fait composé de deux langues, l’une superposée. Le pré-processeur traite une seule langue, à savoir toutes les directives commençant par “#” (et les implications de ces directives). Il traite les directives “#include”, “#define” et d’autres directives, sans toucher au rest du code (sauf en cas d’effet secondaire des directives du préprocesseur, comme les substitutions de macros, etc.).

Ensuite, le compilateur arrive et traite la sortie générée par le pré-processeur. Il traite du langage “C” et ignore pratiquement les directives du pré-processeur.

La réponse à votre question est que “#include” est une partie du langage traité par le pré-processeur, et dans ce langage “;” ne sont pas obligatoires et sont, en fait, des “jetons supplémentaires”.