C Header-bestanden begrijpen: Typen, gebruik en best practices

Een header-bestand is een bestand met extensie .h dat C-functiedeclaraties en macro-definities bevat om te delen tussen verschillende bronbestanden. Er zijn twee typen header-bestanden: de bestanden die de programmeur schrijft en de bestanden die meegeleverd worden met de compiler.

Je vraagt om een header-bestand in je programma te gebruiken door het op te nemen met de C-preprocessing directive #include, zoals je de opname van het stdio.h header-bestand hebt gezien, dat meegeleverd wordt met je compiler.

Het opnemen van een header-bestand is gelijk aan het kopiëren van de inhoud van het header-bestand, maar we doen dat niet omdat het foutgevoelig is en geen goed idee is om de inhoud van een header-bestand in de bronbestanden te kopiëren, vooral als we meerdere bronbestanden in een programma hebben.

Een eenvoudige praktijk in C of C++ programma's is dat we alle constanten, macro's, systeembrede globale variabelen en functieprototypes in de header-bestanden bewaren en dat header-bestand opnemen waar het nodig is.

Include Syntaxis

Zowel gebruikers- als systeemheader-bestanden worden opgenomen met de preprocessing directive #include. Het heeft de volgende twee vormen:

#include <bestand>

Deze vorm wordt gebruikt voor systeemheader-bestanden. Het zoekt naar een bestand met de naam 'bestand' in een standaardlijst van systeemdirectories. Je kunt directories aan deze lijst toevoegen met de -I optie tijdens het compileren van je broncode.

#include "bestand"

Deze vorm wordt gebruikt voor header-bestanden van je eigen programma. Het zoekt naar een bestand met de naam 'bestand' in de directory die het huidige bestand bevat. Je kunt directories aan deze lijst toevoegen met de -I optie tijdens het compileren van je broncode.

Include Bewerking

De #include directive werkt door de C-preprocessor te laten scannen het gespecificeerde bestand als invoer voordat hij doorgaat met de rest van het huidige bronbestand. De uitvoer van de preprocessor bevat de al gegenereerde uitvoer, gevolgd door de uitvoer voortkomend uit het opgenomen bestand, gevolgd door de uitvoer die komt van de tekst na de #include directive. Als je bijvoorbeeld een header-bestand header.h hebt als volgt:

char *test (void);

en een hoofdprogramma genaamd program.c dat het header-bestand gebruikt, als volgt:

int x;
#include "header.h"
int main (void) {
    puts (test ());
}

zal de compiler dezelfde token-stroom zien alsof program.c zou lezen:

int x;
char *test (void);
int main (void) {
    puts (test ());
}

Eenmalige Headers

Als een header-bestand tweemaal opgenomen wordt, zal de compiler de inhoud tweemaal verwerken en dat resulteert in een fout. De standaardmanier om dit te voorkomen is om de volledige echte inhoud van het bestand in een conditionele te plaatsen, als volgt:

#ifndef HEADER_BESTAND
#define HEADER_BESTAND
de volledige header-bestandsinhoud
#endif

Deze constructie is algemeen bekend als een wrapper #ifndef. Wanneer de header opnieuw opgenomen wordt, zal de conditionele false zijn, omdat HEADER_BESTAND gedefinieerd is. De preprocessor zal de volledige inhoud van het bestand overslaan, en de compiler zal het niet tweemaal zien.

Berekende Includes

Soms is het nodig om één van de verschillende verschillende header-bestanden te selecteren om in je programma op te nemen. Bijvoorbeeld, ze kunnen configuratieparameters specificeren die gebruikt worden op verschillende besturingssystemen. Je zou dit kunnen doen met een reeks conditionals als volgt:

#if SYSTEEM_1
# include "systeem_1.h"
#elif SYSTEEM_2
# include "systeem_2.h"
#elif SYSTEEM_3
...
#endif

Maar naarmate het groeit, wordt het vervelend. In plaats daarvan biedt de preprocessor de mogelijkheid om een macro voor de header-naam te gebruiken. Dit heet een berekende include. In plaats van een header-naam als direct argument van #include te schrijven, zet je simpelweg een macro-naam daar:

#define SYSTEEM_H "systeem_1.h"
...
#include SYSTEEM_H

SYSTEEM_H zal uitgebreid worden, en de preprocessor zal zoeken naar systeem_1.h alsof de #include oorspronkelijk zo geschreven was. SYSTEEM_H kan gedefinieerd worden door je Makefile met een -D optie.