Vooraf gecompileerde headerbestanden

Wanneer u een nieuw project in Visual Studio maakt, wordt er een vooraf gecompileerd headerbestand met de naam pch.h toegevoegd aan het project. (In Visual Studio 2017 en eerder werd het bestand . stdafx.h) Het doel van het bestand is om het buildproces te versnellen. Eventuele stabiele headerbestanden, bijvoorbeeld Standard Library-headers zoals <vector>, moeten hier worden opgenomen. De vooraf gecompileerde header wordt alleen gecompileerd wanneer deze, of bestanden die erin zijn opgenomen, worden gewijzigd. Als u alleen wijzigingen aanbrengt in de broncode van uw project, wordt de compilatie voor de vooraf gecompileerde header overgeslagen.

De compileropties voor vooraf gecompileerde headers zijn /Y. Op de projecteigenschapspagina's bevinden de opties zich onder Configuratie-eigenschappen>C/C++>Vooraf gecompileerde headers. U kunt ervoor kiezen geen vooraf gecompileerde headers te gebruiken en u kunt de naam van het headerbestand en de naam en het pad van het uitvoerbestand opgeven.

Aangepaste vooraf gecompileerde code

Voor grote projecten die veel tijd in beslag nemen om te bouwen, kunt u overwegen om aangepaste vooraf gecompileerde bestanden te maken. De Microsoft C- en C++-compilers bieden opties voor het vooraf compileren van C- of C++-code, inclusief inlinecode. Met deze prestatiefunctie kunt u een stabiele codetekst compileren, de gecompileerde status van de code opslaan in een bestand en tijdens volgende compilaties de vooraf gecompileerde code combineren met code die nog in ontwikkeling is. Elke latere compilatie is sneller omdat de stabiele code niet opnieuw hoeft te worden gecompileerd.

Wanneer moet u de broncode vooraf compileren

Vooraf gecompileerde code is nuttig tijdens de ontwikkelingscyclus om de compilatietijd te verkorten, met name als:

• U gebruikt altijd een grote codetekst die zelden wordt gewijzigd.

• Uw programma bestaat uit meerdere modules, die allemaal gebruikmaken van een standaardset include-bestanden en dezelfde compilatieopties. In dit geval kunnen alle include-bestanden vooraf worden gecompileerd in één voorgecompileerde header. Voor meer informatie over nieuwere manieren om invoegbestanden te verwerken, zie Header-eenheden, modules en vooraf gecompileerde headers vergelijken.

De eerste compilatie (de compilatie die het vooraf gecompileerde headerbestand maakt) duurt iets langer dan volgende compilaties. Volgende compilaties kunnen sneller worden voortgezet door de vooraf gecompileerde code op te delen.

U kunt zowel C- als C++-programma's vooraf compileren. In C++-programmering is het gebruikelijk om informatie over de klasse-interface te scheiden in headerbestanden. Deze headerbestanden kunnen later worden opgenomen in programma's die gebruikmaken van de klasse. Door deze headers vooraf te compileren, kunt u de tijd beperken die een programma nodig heeft om te compileren.

Twee opties voor het vooraf compileren van code

U kunt elke C- of C++-code vooraf compileren; U bent niet beperkt tot het vooraf compileren van alleen headerbestanden.

Voor precompileren is planning vereist, maar het biedt veel snellere compilaties als u andere broncode dan eenvoudige headerbestanden vooraf compileert.

Code vooraf compileren wanneer u weet dat uw bronbestanden algemene sets headerbestanden gebruiken of wanneer u broncode wilt opnemen in uw precompilatie.

De opties voor vooraf gecompileerde headers zijn /Yc (Vooraf gecompileerd headerbestand maken) en /Yu (Vooraf gecompileerd headerbestand gebruiken). Hiermee /Yc maakt u een vooraf gecompileerde header. Wanneer u deze gebruikt met de optionele hdrstop pragma, /Yc kunt u zowel headerbestanden als broncode vooraf compileren. Selecteer /Yu deze optie om een bestaande vooraf gecompileerde header te gebruiken in de bestaande compilatie. U kunt ook /Fp met de /Yc en /Yu opties een alternatieve naam opgeven voor de vooraf gecompileerde header.

De naslagartikelen over compileropties voor /Yu en /Yc bespreken hoe u toegang krijgen tot deze functionaliteit in de ontwikkelomgeving.

Regels voor vooraf gecompileerde headerconsistentie

Omdat PCH-bestanden informatie bevatten over de computeromgeving en geheugenadresinformatie over het programma, moet u alleen een PCH-bestand gebruiken op de computer waarop het is gemaakt.

Consistentieregels voor gebruik per bestand van vooraf gecompileerde headers

Met de /Yu compileroptie kunt u opgeven welk PCH-bestand moet worden gebruikt.

Wanneer u een PCH-bestand gebruikt, gaat de compiler uit van dezelfde compilatieomgeving die van kracht was toen u het PCH-bestand maakte, tenzij u anders opgeeft. De compilatieomgeving bevat de compileropties, pragma's, enzovoort. Als de compiler inconsistentie detecteert, geeft deze een waarschuwing uit en identificeert deze waar mogelijk de inconsistentie. Dergelijke waarschuwingen geven niet noodzakelijkerwijs een probleem aan met het PCH-bestand; ze waarschuwen u gewoon voor mogelijke conflicten. Consistentievereisten voor PCH-bestanden worden beschreven in de volgende secties.

Consistentie van compileropties

De volgende compileropties kunnen een inconsistentiewaarschuwing activeren wanneer u een PCH-bestand gebruikt:

• Macro's die zijn gemaakt met de optie Preprocessor (/D) moeten hetzelfde zijn tussen de compilatie die het PCH-bestand en de huidige compilatie heeft gemaakt. De status van gedefinieerde constanten wordt niet gecontroleerd, maar onvoorspelbare resultaten kunnen optreden als deze macro's veranderen.

• PCH-bestanden werken niet met de /E en /EP opties.

• PCH-bestanden moeten worden gemaakt met de optie Browsegegevens genereren (/FR) of de optie Lokale variabelen uitsluiten (/Fr) voordat volgende compilaties die gebruikmaken van het PCH-bestand deze opties kunnen gebruiken.

C 7.0-compatibel (/Z7)

Als deze optie van kracht is wanneer het PCH-bestand wordt gemaakt, kunnen latere compilaties die gebruikmaken van het PCH-bestand de foutopsporingsgegevens gebruiken.

Als de optie C 7.0-Compatibel (/Z7) niet van kracht is wanneer het PCH-bestand wordt gemaakt, zal bij latere compilaties die het PCH-bestand en /Z7 gebruiken een waarschuwing worden geactiveerd. De foutopsporingsgegevens worden in het huidige .obj bestand geplaatst en lokale symbolen die zijn gedefinieerd in het PCH-bestand zijn niet beschikbaar voor het foutopsporingsprogramma.

Padconsistentie opnemen

Een PCH-bestand bevat geen informatie over de header, inclusief het pad dat van kracht was toen het werd gemaakt. Wanneer u een PCH-bestand gebruikt, gebruikt de compiler altijd het header include-pad dat is opgegeven in de huidige compilatie.

Consistentie van bronbestand

Wanneer u de optie Precompiled Header File (/Yu) gebruiken opgeeft, negeert de compiler alle preprocessorrichtlijnen (inclusief pragma's) die worden weergegeven in de broncode die vooraf wordt gecompileerd. De compilatie die door dergelijke preprocessorrichtlijnen is opgegeven, moet gelijk zijn aan de compilatie die wordt gebruikt voor de optie Precompiled Header File (/Yc) maken.

Pragma-consistentie

Pragmas verwerkt tijdens het maken van een PCH-bestand is meestal van invloed op het bestand waarmee het PCH-bestand later wordt gebruikt. De comment en message pragma's hebben geen invloed op de rest van de compilatie.

Deze pragma's zijn alleen van invloed op de code in het PCH-bestand; ze hebben geen invloed op code die later gebruikmaakt van het PCH-bestand:

Deze pragma's worden bewaard als onderdeel van een vooraf gecompileerde header en beïnvloeden de rest van een compilatie die gebruikmaakt van de vooraf gecompileerde header:

Consistentieregels voor /Yc en /Yu

Wanneer u een vooraf gecompileerde header gebruikt die is gemaakt met of /Yc/Yu, vergelijkt de compiler de huidige compilatieomgeving met de omgeving die bestond toen u het PCH-bestand maakte. Zorg ervoor dat u een omgeving opgeeft die consistent is met de vorige omgeving (met behulp van consistente compileropties, pragma's, enzovoort) voor de huidige compilatie. Als de compiler inconsistentie detecteert, geeft deze een waarschuwing uit en identificeert deze waar mogelijk de inconsistentie. Dergelijke waarschuwingen geven niet noodzakelijkerwijs een probleem aan met het PCH-bestand; ze waarschuwen u gewoon voor mogelijke conflicten. In de volgende secties worden de consistentievereisten voor vooraf gecompileerde headers uitgelegd.

Consistentie van compileropties

Deze tabel bevat compileropties die mogelijk een inconsistentiewaarschuwing activeren bij het gebruik van een vooraf gecompileerde header:

Vooraf gecompileerde headers in een project gebruiken

In eerdere secties ziet u een overzicht van vooraf gecompileerde headers: /Yc en /Yu, de optie /Fp en de hdrstop pragma. In deze sectie wordt een methode beschreven voor het gebruik van de handmatige opties voor vooraf gecompileerde headers in een project; het eindigt met een voorbeeld makefile en de code die wordt beheerd.

Voor een andere benadering voor het gebruik van de handmatige opties voor vooraf gecompileerde headers in een project, moet u een van de makefiles in de MFC\SRC map bestuderen die tijdens de standaardinstallatie van Visual Studio zijn gemaakt. Deze makefiles hebben een vergelijkbare benadering als die in deze sectie wordt gepresenteerd. Ze maken meer gebruik van NMAKE-macro's (Microsoft Program Maintenance Utility) en bieden meer controle over het buildproces.

PCH-bestanden in het buildproces

De codebasis van een softwareproject bevindt zich vaak in meerdere C- of C++-bronbestanden, objectbestanden, bibliotheken en headerbestanden. Meestal coördineert een makefile de combinatie van deze elementen in een uitvoerbaar bestand. In de volgende afbeelding ziet u de structuur van een makefile die gebruikmaakt van een vooraf gecompileerd headerbestand. De NMAKE-macronamen en de bestandsnamen in dit diagram zijn consistent met de voorbeeldcode in sample makefile voor PCH en voorbeeldcode voor PCH.

In de afbeelding worden drie diagrammatische technieken gebruikt om het verloop van het bouwproces weer te geven. Benoemde rechthoeken vertegenwoordigen elk bestand of elke macro; de drie macro's vertegenwoordigen een of meer bestanden. Gearceerde gebieden geven elke compileer- of koppelingsactie weer. Pijlen geven aan welke bestanden en macro's worden gecombineerd tijdens het compilatie- of koppelingsproces.

Structuur van een makefile die gebruikmaakt van een vooraf gecompileerd headerbestand:

Vanaf het begin van het diagram zijn beide STABLEHDRSBOUNDRY NMAKE-macro's waarin u bestanden weergeeft die waarschijnlijk niet opnieuw moeten worden gecompileert. Deze bestanden worden gecompileerd door de opdrachtreeks

CL /c /W3 /Yc$(BOUNDRY) applib.cpp myapp.cpp

alleen als het vooraf gecompileerde headerbestand (STABLE.pch) niet bestaat of als u wijzigingen aanbrengt in de bestanden die in de twee macro's worden vermeld. In beide gevallen bevat het vooraf gecompileerde headerbestand alleen code uit de bestanden die in de STABLEHDRS macro worden vermeld. Geef het laatste bestand weer dat u vooraf wilt compileren in de BOUNDRY macro.

De bestanden die u in deze macro's opneemt, kunnen headerbestanden of C- of C++-bronbestanden zijn. (Een enkel PCH-bestand kan niet worden gebruikt met zowel C- als C++-bronnen.) U kunt de hdrstop macro gebruiken om de precompilatie op een bepaald moment in het BOUNDRY bestand te stoppen. Zie hdrstop voor meer informatie.

Vervolgens geeft u in het diagram APPLIB.obj de ondersteuningscode weer die wordt gebruikt in uw uiteindelijke toepassing. Het wordt gemaakt uit APPLIB.cpp, de bestanden in macro UNSTABLEHDRS en code uit de vooraf gecompileerde header.

MYAPP.obj vertegenwoordigt uw uiteindelijke toepassing. Het wordt gemaakt uit MYAPP.cpp, de bestanden in macro UNSTABLEHDRS en code uit de vooraf gecompileerde header.

Ten slotte wordt het uitvoerbare bestand (MYAPP.EXE) gemaakt door de bestanden in de OBJS macro (APPLIB.obj en MYAPP.obj) te koppelen.

Voorbeeld makefile voor PCH

De volgende makefile maakt gebruik van macro's en een !IF, !ELSE!ENDIF flow-of-control opdrachtstructuur om de aanpassing aan uw project te vereenvoudigen.

# Makefile : Illustrates the effective use of precompiled
#            headers in a project
# Usage:     NMAKE option
# option:    DEBUG=[0|1]
#            (DEBUG not defined is equivalent to DEBUG=0)
#
OBJS = myapp.obj applib.obj
# List all stable header files in the STABLEHDRS macro.
STABLEHDRS = stable.h another.h
# List the final header file to be precompiled here:
BOUNDRY = stable.h
# List header files under development here:
UNSTABLEHDRS = unstable.h
# List all compiler options common to both debug and final
# versions of your code here:
CLFLAGS = /c /W3
# List all linker options common to both debug and final
# versions of your code here:
LINKFLAGS = /nologo
!IF "$(DEBUG)" == "1"
CLFLAGS   = /D_DEBUG $(CLFLAGS) /Od /Zi
LINKFLAGS = $(LINKFLAGS) /COD
LIBS      = slibce
!ELSE
CLFLAGS   = $(CLFLAGS) /Oselg /Gs
LINKFLAGS = $(LINKFLAGS)
LIBS      = slibce
!ENDIF
myapp.exe: $(OBJS)
    link $(LINKFLAGS) @<<
$(OBJS), myapp, NUL, $(LIBS), NUL;
<<
# Compile myapp
myapp.obj  : myapp.cpp $(UNSTABLEHDRS)  stable.pch
    $(CPP) $(CLFLAGS) /Yu$(BOUNDRY)    myapp.cpp
# Compile applib
applib.obj : applib.cpp $(UNSTABLEHDRS) stable.pch
    $(CPP) $(CLFLAGS) /Yu$(BOUNDRY)    applib.cpp
# Compile headers
stable.pch : $(STABLEHDRS)
    $(CPP) $(CLFLAGS) /Yc$(BOUNDRY)    applib.cpp myapp.cpp

Afgezien van de STABLEHDRS, BOUNDRYen UNSTABLEHDRS macro's die worden weergegeven in de afbeelding 'Structuur van een makefile die gebruikmaakt van een vooraf gecompileerd headerbestand' in PCH-bestanden in het buildproces, biedt dit makefile een CLFLAGS macro en een LINKFLAGS macro. U moet deze macro's gebruiken om compiler- en linkeropties weer te geven die van toepassing zijn, ongeacht of u een foutopsporing of definitieve versie van het uitvoerbare bestand van de toepassing maakt. Er is ook een LIBS macro waarin u de bibliotheken vermeldt die uw project nodig heeft.

Het makefile maakt ook gebruik van !IF, !ELSE, !ENDIF om te detecteren of u een DEBUG symbool definieert op de NMAKE-opdrachtregel.

NMAKE DEBUG=[1|0]

Met deze functie kunt u dezelfde makefile gebruiken tijdens de ontwikkeling en voor de definitieve versies van uw programma. Gebruiken DEBUG=0 voor de definitieve versies. De volgende opdrachtregels zijn equivalent:

NMAKE
NMAKE DEBUG=0

Zie NMAKE-naslaginformatie voor meer informatie over makefiles. Zie ook de msVC-compileropties en de MSVC-linkeropties.

Voorbeeldcode voor PCH

De volgende bronbestanden worden gebruikt in het makefile dat wordt beschreven in PCH-bestanden in het buildproces en sample makefile voor PCH. De opmerkingen bevatten belangrijke informatie.

Bronbestand ANOTHER.H:

// ANOTHER.H : Contains the interface to code that is not
//             likely to change.
//
#ifndef __ANOTHER_H
#define __ANOTHER_H
#include <iostream>
void savemoretime( void );
#endif // __ANOTHER_H

Bronbestand STABLE.H:

// STABLE.H : Contains the interface to code that is not likely
//            to change. List code that is likely to change
//            in the makefile's STABLEHDRS macro.
//
#ifndef __STABLE_H
#define __STABLE_H
#include <iostream>
void savetime( void );
#endif // __STABLE_H

Bronbestand UNSTABLE.H:

// UNSTABLE.H : Contains the interface to code that is
//              likely to change. As the code in a header
//              file becomes stable, remove the header file
//              from the makefile's UNSTABLEHDR macro and list
//              it in the STABLEHDRS macro.
//
#ifndef __UNSTABLE_H
#define __UNSTABLE_H
#include <iostream>
void notstable( void );
#endif // __UNSTABLE_H

Bronbestand APPLIB.CPP:

// APPLIB.CPP : This file contains the code that implements
//              the interface code declared in the header
//              files STABLE.H, ANOTHER.H, and UNSTABLE.H.
//
#include "another.h"
#include "stable.h"
#include "unstable.h"
using namespace std;
// The following code represents code that is deemed stable and
// not likely to change. The associated interface code is
// precompiled. In this example, the header files STABLE.H and
// ANOTHER.H are precompiled.
void savetime( void )
    { cout << "Why recompile stable code?\n"; }
void savemoretime( void )
    { cout << "Why, indeed?\n\n"; }
// The following code represents code that is still under
// development. The associated header file is not precompiled.
void notstable( void )
    { cout << "Unstable code requires"
            << " frequent recompilation.\n";
    }

Bronbestand MYAPP.CPP:

// MYAPP.CPP : Sample application
//             All precompiled code other than the file listed
//             in the makefile's BOUNDRY macro (stable.h in
//             this example) must be included before the file
//             listed in the BOUNDRY macro. Unstable code must
//             be included after the precompiled code.
//
#include "another.h"
#include "stable.h"
#include "unstable.h"
int main( void )
{
    savetime();
    savemoretime();
    notstable();
}

Zie ook

Header-eenheden, modules en voorgecompileerde headers vergelijken
C/C++-bouwreferentie
MSVC-compileropties
Overzicht van modules in C++
Zelfstudie: De standaardbibliotheek van C++ importeren met behulp van modules
Walkthrough: Header-eenheden bouwen en importeren in uw Microsoft C++-projecten
Handleiding: STL-bibliotheken importeren als header-eenheden