Les directives de préprocesseur telles que #include peuvent-elles être placées uniquement en haut du code du programme?

J’ai utilisé la directive #pragma intérieur des fonctions sans erreur ni avertissement (en particulier #pragma pack() ) .Mais le code suivant montre la incompatible implicit declaration of built-in function 'printf'| avertissement incompatible implicit declaration of built-in function 'printf'| :

 int main(void) { printf("Trial"); } #include 

En outre, voici un extrait d’un livre que j’ai. L’auteur a de mauvaises critiques sur SO, en particulier pour son utilisation généreuse de void main() , mais j’estime néanmoins qu’aucun auteur ne peut être si mauvais que de prétendre ce qui suit sans raison:

Chacune de ces directives de préprocesseur commence par un symbole #. Les directives peuvent être placées n’importe où dans un programme, mais sont le plus souvent placées au début d’un programme, avant la définition de la première fonction.

Alors pouvez-vous me dire s’il est obligatoire d’utiliser des directives de préprocesseur telles que #include en haut du programme, tandis que d’autres comme #pragma peuvent être utilisées n’importe où dans le programme?

Edit Après la remarque de OUAH , j’ai essayé ce qui suit, mais cela ne donne pas d’avertissement, cela donne un gros tas d’ erreurs .LOL.

 int main(void) { #include printf("Trial"); } 

Une directive #include peut être placée n’importe où dans un fichier source, mais en C, un identifiant ne peut généralement pas être utilisé avant sa déclaration. C’est la raison pour laquelle vous avez mis la directive #include au début de votre fichier source.

 void foo(void) { printf("Hello world\n"); } extern int printf(const char *, ...); // Error, the declaration should be put // before the actual call 

Pense-y de cette façon. Le contenu du fichier inclus est simplement inséré à l’endroit du fichier où la directive #include apparaît. Le code résultant doit être syntaxiquement correct pour le langage que vous programmez.

Confider le fichier suivant:

 int a; int foo(); int main() #include "myheader.h" int foo() { return 0; } 

Et le fichier myheader.h contient:

 { return foo(); } 

Le code que le compilateur verra une fois que le préprocesseur aura traité la directive #include est le suivant:

 int a; int foo(); int main() { return foo(); } int foo() { return 0; } 

Ceci est la syntaxe C valide. Une telle utilisation de la directive #include n’est pas recommandée, mais elle vous donne une idée de ce que cela signifie. Si le fichier myheader.h avait le contenu suivant:

 this is some garbage which is not proper C 

Alors le code résultant sera:

 int a; int foo(); int main() this is some garbage which is not proper C int foo() { return 0; } 

Vous pouvez utiliser #include à tout moment dans le fichier. Il en résulte une inclusion littérale du contenu du fichier inclus à ce stade. La raison pour laquelle vous obtenez un message non déclaré pour printf () dans votre code est que C demande qu’une fonction soit déclarée avant son utilisation et que stdio.h possède cette déclaration. C’est pourquoi il doit être avant de l’utiliser. Et la raison pour laquelle il ne peut pas être inclus dans main () dans le dernier exemple, c’est que lorsqu’il est inclus (expansion), il en résulte un code C syntaxiquement incorrect.

La directive “#pragma” sera ignorée par le compilateur C car il considère les lignes avec la balise “#” comme des commentaires. On dirait que vous utilisez openmp. Le compilateur OpenMP les considère (#pragma) comme des directives parallèles. J’espère que cela t’aides.