Quina diferència hi ha entre els fitxers de capçalera i els fitxers font de C ++?


Resposta 1:

La gent utilitza fitxers de capçalera per organitzar fitxers en un paquet. Podeu veure fàcilment el que té un paquet llegint els fitxers de capçalera, on les declaracions estan ordenades (i generalment comentades). Podeu fer-vos una idea del funcionament sense haver de desplaçar-vos per línies de codi.

Els fitxers font són generalment on es defineix el codi real.

Aquest és un exemple de genèric C, per la qual cosa no serà precisa la sintaxi C ++ (estic rovellada):

/ * foo.h * /
void func1 (int, int);

(Fitxer separat)

/ * foo.c * /
#incloure "foo.h"
int principal () {func1 (3,3); }

void func1 (int x, int y) {
    retornar x + 2 * y * y;
}

Veus com heu pogut utilitzar func1 a la pàgina principal de foo.c sense haver de redefinir? Aquesta és una altra cosa sobre els fitxers de capçalera: podeu posar les funcions més petites per sota de tot (ja que el principal és el més important).

A C ++ tenim moltes més funcionalitats: classes, espais d’esdeveniments, etc. Encara no és dolent organitzar fitxers de manera ordenada. Per exemple, podem fer declaracions de classe en una capçalera i, a continuació, definir les funcions de classe al codi font.


Resposta 2:

La resposta senzilla és: els fitxers de capçalera descriuen una interfície; no contenen implementació d'algorisme. Això és per a què serveixen els fitxers d'origen.

Però això és només una explicació molt superficial. En realitat podeu implementar la funcionalitat als fitxers de capçaleres. Hi arribaré, però primer, quina és una diferència pràctica entre un "fitxer de capçalera" i un "fitxer font"?

La resposta és: no hi ha cap diferència, excepte la convencional. La directiva #incloure el pre-processador permet inclinear qualsevol fitxer al punt del seu lloc. Però (tret de casos molt especials), no voldreu incloure el vostre codi general (els fitxers font). El que normalment necessiteu és incorporar informació del tipus i especificació de la interfície (declaracions de funcions) per poder-los utilitzar.

Si introduïu el vostre codi, significaria que es multiplicaria a tots els fitxers que fan el #include (de nou el preprocessador només copia cegament el contingut com si estigués escrit al punt de la directiva). I això probablement causaria un comportament no desitjat.

Torna a la implementació de la funcionalitat als fitxers "capçalera". Hi definiu algun codi:

  • Macros. Una macro s'expandeix en el moment del seu ús. El preprocessador ho fa, de nou, i és una reescriptura directa de l'ús del definiendum macro per part dels seus definiens (opcionalment parametrisats). No "crideu" cap macro; el seu ús acaba de tornar a escriure abans de les funcions compilation.Inline. Aquests (podrien no) funcionar de la mateixa manera que les macros. Excepte que el compilador pugui decidir definir una funció veritable (i generar la seva trucada) en lloc d’incloure el contingut de la funció. Es generaria una funció comuna per a cada #include (tret que es consideri implícitament en línia, vegeu més avall). Mireu, el declarador en línia no és vinculant per al compilador; pot incloure, però pot no, és només un "toc". De fet, l’estàndard C ++ 17 canvia la semàntica d’inline en “definicions múltiples permeses”. Així que tingueu cura; si, per exemple, hauríeu creat una funció en línia amb dades estàtiques dins, podeu acabar amb diverses instàncies de dades estàtiques (cadascuna per a una definició de la funció). Probablement no és el que volíeu ... Codi de plantilla. Les plantilles s’inicialitzen. Quan utilitzeu una plantilla per crear un tipus concret, el compilador crearà aquest tipus localment (de la mateixa manera que si el definiu "manualment" al punt d'utilitzar-lo). Les funcions de les plantilles es consideren implícitament en línia (però el compilador decidirà, i sovint, no incloure-les pel tipus generat).

Així, en general, definiu els vostres tipus (públics) i declareu les vostres funcions als fitxers de capçalera. També definiu les vostres macros, plantilles i funcions en línia. Definiu les vostres funcions als fitxers d'origen i també hi feu declarar / definir les funcions locals, no públiques i tipus estàtiques. Les capçaleres són claus per accedir a la funcionalitat, les fonts implementen la funcionalitat.

Els fitxers font es compilen en fitxers "objecte". Aquests inclouran tot el codi generat a partir de l’origen i que també conté tot el codi definit als fitxers de capçalera que el fitxer font #inclou (recordeu que el codi s’inclina al punt de la directiva d’ús). I, finalment, el vostre programa (o biblioteca) consta d’aquests fitxers d’objectes enllaçats entre si.

Espero que això ajudi.


Resposta 3:

Els fitxers d'origen són els fitxers que contenen el codi que es recopila. La implementació del vostre algorisme es troba en un fitxer font.

Els fitxers de capçalera contenen codi (normalment definicions de funció o de classe) que es copien al fitxer font mitjançant la directiva #include preprocessor. El gran avantatge d’utilitzar fitxers de capçalera és la reutilització. Vull dir només imagina’t si haguéssiu d’escriure el codi per a la definició de la classe de cadena cada vegada que vulgueu utilitzar-la, quan ho faria un simple #include .


Resposta 4:

Heu introduït coses en un fitxer de capçalera. D'altres fitxers font s'utilitzaran (per altra cosa vull dir que el fitxer font que no implementa les coses definides a una capçalera)

Per ser pedants, els fitxers de capçalera són una convenció en C i C ++. Alguns compiladors potser no els importa si expliqueu que compili un fitxer amb extensió .h.

C va adoptar una ruta primitiva, però raonablement potent i flexible d'implementació d'un pre-processador. Gestiona #incloure i tals. El compilador només veu el fitxer un cop totes les incloses són ... incloses. Mai es compila una capçalera per convenció. Només s’inclou (tingueu en compte que CONVENTION, hi ha excepcions). Per tant, només heu d'introduir coses a les capçaleres que permeten un fitxer font per saber què hi ha disponibles en un altre fitxer font, com ara funcions. O per tipus habituals. O macros útils. O… bé… hi ha molts usos.