Dois-je comstackr les fichiers d’en-tête dans un programme C?

Parfois, je vois quelqu’un comstackr un programme C comme ceci:

gcc -o hello hello.c hello.h

Comme je le sais, il suffit de placer les fichiers d’en-tête dans le programme C comme:

#include "somefile"

et comstackr le programme C: gcc -o hello hello.c .

Quand devons-nous comstackr les fichiers d’en-tête ou pourquoi?

Premièrement, en général:

Si ces fichiers .h sont en fait des fichiers d’en-tête de type C (contrairement à ce qui se passe avec l’extension .h ), alors non, il n’y a aucune raison de “comstackr” ces fichiers d’en-tête indépendamment. Les fichiers d’en-tête sont destinés à être inclus dans les fichiers d’implémentation, et ne sont pas transmis au compilateur en tant qu’unités de traduction indépendantes.

Comme un fichier d’entête typique ne contient généralement que des déclarations pouvant être répétées en toute sécurité dans chaque unité de traduction, il est parfaitement attendu que la “compilation” d’un fichier d’en-tête n’ait pas de conséquences préjudiciables. Mais en même temps, il ne sera pas utile.

Fondamentalement, comstackr hello.h tant qu’unité de traduction autonome équivaut à créer un fichier dummy.c dégénéré constitué uniquement de la directive #include "hello.h" et à dummy.c fichier dummy.c au compilateur. Il va comstackr, mais cela ne servira à rien.


Deuxièmement, spécifiquement pour GCC:

De nombreux compilateurs traiteront les fichiers différemment en fonction de l’extension du nom du fichier. GCC a un traitement spécial pour les fichiers avec l’extension .h lorsqu’ils sont fournis au compilateur en tant qu’arguments de ligne de commande. Au lieu de le traiter comme une unité de traduction standard, GCC crée un fichier d’en- tête précompilé pour ce fichier .h .

Vous pouvez lire à ce sujet ici: http://gcc.gnu.org/onlinedocs/gcc/Precomstackd-Headers.html

Donc, c’est la raison pour laquelle vous pourriez voir les fichiers .h directement à GCC.

Bon, comprenons la différence entre le code actif et le code passif.

Le code actif est l’implémentation de fonctions, procédures, méthodes, c’est-à-dire les morceaux de code à comstackr en code machine exécutable. Nous le stockons dans des fichiers .c et nous sums sûrs de devoir le comstackr.

Le code passif n’est pas en train de s’exécuter, mais il faut expliquer aux différents modules comment communiquer entre eux. Généralement, les fichiers .h ne contiennent que des prototypes (en-têtes de fonction), des structures.

Les macros constituent une exception, car elles peuvent formellement contenir des pièces actives, mais vous devez comprendre qu’elles sont utilisées au tout début de la construction (prétraitement) avec une simple substitution. Au moment de la compilation, les macros sont déjà remplacées par votre fichier .c.

Une autre exception concerne les modèles C ++, qui doivent être implémentés dans les fichiers .h. Mais voici l’histoire similaire aux macros: elles sont substituées au début (instanciation) et formellement, chaque autre instanciation est un autre type.

En conclusion, je pense que si les modules se sont formés correctement, nous ne devrions jamais comstackr les fichiers d’en-tête.

Je pense que nous avons besoin d’un prétraitement (peut-être pas appeler la compilation) du fichier principal. Parce que de ma compréhension, pendant la phase de compilation, le fichier principal doit être inclus dans le fichier c. Par exemple, dans test.h nous avons

 typedef enum{ a, b, c }test_t 

et dans test.c nous avons

 void foo() { test_t test; ... } 

Pendant la compilation, je pense que le compilateur mettra le code dans le fichier principal et le fichier c ensemble et que le code dans le fichier principal sera prétraité et remplacera le code dans le fichier c. En attendant, il serait préférable de définir le chemin d’inclusion dans le fichier makefile.

Dans certains systèmes, les tentatives d’accélération de l’assemblage de fichiers «.c» entièrement résolus appellent le pré-assemblage des fichiers d’inclusion «compilation de fichiers d’en-tête». Cependant, il s’agit d’une technique d’optimisation qui n’est pas nécessaire pour un développement réel du C.

Une telle technique a essentiellement calculé les instructions include et conservé un cache des inclusions aplaties. Normalement, l’outil C va couper et coller les fichiers inclus de manière récursive, puis transmettre l’élément complet au compilateur. Avec un cache d’en-tête pré-compilé, la chaîne d’outils vérifiera si l’une des entrées (définition, en-tête, etc.) a changé. Si ce n’est pas le cas, le compilateur recevra alors les extraits de fichiers texte déjà aplatis.

Ces systèmes étaient destinés à accélérer le développement; Cependant, beaucoup de ces systèmes étaient assez fragiles. Au fur et à mesure que les ordinateurs accéléraient et que les techniques de gestion du code source changeaient, le nombre de pré-compilateurs d’en-tête utilisés dans le projet commun était inférieur.

Jusqu’à ce que vous ayez réellement besoin d’optimiser la compilation, je vous recommande fortement d’éviter de pré-comstackr les en-têtes.