Creazione di file di intestazione precompilataCreating Precompiled Header Files

I compilatori Microsoft C e C++ includono opzioni per la precompilazione di codice C o C++ di qualsiasi tipo, incluso quello inline.The Microsoft C and C++ compilers provide options for precompiling any C or C++ code, including inline code. Questa funzionalità avanzata consente di compilare un corpo di codice stabile, archiviare lo stato del codice compilato in un file e, durante le successive compilazioni, combinare il codice precompilato con quello ancora in fase di sviluppo.Using this performance feature, you can compile a stable body of code, store the compiled state of the code in a file, and, during subsequent compilations, combine the precompiled code with code that is still under development. Le compilazioni successive risultano più veloci perché il codice stabile non deve essere ricompilato.Each subsequent compilation is faster because the stable code does not need to be recompiled.

In questo argomento vengono trattati gli argomenti di intestazione precompilata seguenti:This topic covers the following precompiled header subjects:

Per informazioni sulle opzioni del compilatore correlate alle intestazioni precompilate, vedere /Y (intestazioni precompilate).For reference information on the compiler options related to precompiled headers, see /Y (Precompiled Headers).

Condizioni per la precompilazione del codice sorgenteWhen to Precompile Source Code

Il codice precompilato è utile durante il ciclo di sviluppo per ridurre i tempi di compilazione, soprattutto se:Precompiled code is useful during the development cycle to reduce compilation time, especially if:

  • È sempre utilizzare gran parte del codice che vengono modificati raramente.You always use a large body of code that changes infrequently.

  • Il programma è costituito da più moduli, ognuno dei quali utilizzerà un set standard di file di inclusione e le stesse opzioni di compilazione.Your program comprises multiple modules, all of which use a standard set of include files and the same compilation options. In questo caso, tutti i file di inclusione può essere precompilato in un'intestazione precompilata.In this case, all include files can be precompiled into one precompiled header.

La prima compilazione, ovvero quello che crea il file di intestazione precompilata (PCH), richiede più tempo rispetto alle compilazioni successive.The first compilation — the one that creates the precompiled header (PCH) file — takes a bit longer than subsequent compilations. Le successive compilazioni possono essere più rapide, includendo il codice precompilato.Subsequent compilations can proceed more quickly by including the precompiled code.

È possibile precompilare programmi C e C++.You can precompile both C and C++ programs. In linguaggi di programmazione C++, è pratica comune per separare le informazioni di interfaccia di classe nel file di intestazione.In C++ programming, it is common practice to separate class interface information into header files. Questi file di intestazione in un secondo momento possono essere inclusi nei programmi che usano la classe.These header files can later be included in programs that use the class. La precompilazione di queste intestazioni, è possibile ridurre il tempo di un programma per la compilazione.By precompiling these headers, you can reduce the time a program takes to compile.

Nota

Sebbene sia possibile utilizzare un solo file di intestazione precompilata (PCH) per ogni file di origine, è possibile utilizzare più PCH (file) in un progetto.Although you can use only one precompiled header (.pch) file per source file, you can use multiple .pch files in a project.

Precompilazione del codice automatica e manualeTwo Choices for Precompiling Code

Con Visual C++, è possibile precompilare qualsiasi codice C o C++. non è possibile eseguire solo i file di intestazione di precompilazione.With Visual C++, you can precompile any C or C++ code; you are not limited to precompiling only header files.

La precompilazione richiede una pianificazione, ma consente di eseguire compilazioni significativamente più veloce se si esegue la precompilazione di codice sorgente diverso da semplici file di intestazione.Precompiling requires planning, but it offers significantly faster compilations if you precompile source code other than simple header files.

Precompilazione del codice quando si è certi che i file di origine comune set di file di intestazione, ma non li includono nello stesso ordine o quando si desidera includere codice sorgente nella precompilazione.Precompile code when you know that your source files use common sets of header files but don't include them in the same order, or when you want to include source code in your precompilation.

Le opzioni di intestazione precompilata sono /Yc (Crea precompilata File di intestazione) e /Yu (utilizza il File intestazione precompilata).The precompiled-header options are /Yc (Create Precompiled Header File) and /Yu (Use Precompiled Header File). Utilizzare /Yc per creare un'intestazione precompilata.Use /Yc to create a precompiled header. Se usato con l'opzione facoltativa hdrstop pragma, /Yc consente di precompilare entrambi i file di intestazione e il codice sorgente.When used with the optional hdrstop pragma, /Yc lets you precompile both header files and source code. Selezionare /Yu per utilizzare un'intestazione precompilata esistente nella compilazione esistente.Select /Yu to use an existing precompiled header in the existing compilation. È inoltre possibile utilizzare /Fp con il /Yc e /Yu le opzioni per fornire un nome alternativo per l'intestazione precompilata.You can also use /Fp with the /Yc and /Yu options to provide an alternative name for the precompiled header.

Gli argomenti di riferimento di opzione del compilatore per /Yu e /Yc viene illustrato come accedere a questa funzionalità nell'ambiente di sviluppo.The compiler option reference topics for /Yu and /Yc discuss how to access this functionality in the development environment.

Regole di uniformità per le intestazioni precompilatePrecompiled Header Consistency Rules

Poiché i file PCH contengono informazioni sull'ambiente del computer, nonché informazioni sull'indirizzo di memoria sul programma, utilizzare solo un file PCH nel computer in cui è stato creato.Because PCH files contain information about the machine environment as well as memory address information about the program, you should only use a PCH file on the machine where it was created.

Regole di uniformità per l'utilizzo per singolo file delle intestazioni precompilateConsistency Rules for Per-File Use of Precompiled Headers

Il /Yu l'opzione del compilatore consente di specificare il file PCH da utilizzare.The /Yu compiler option lets you specify which PCH file to use.

Quando si utilizza un file PCH, il compilatore presuppone lo stesso ambiente di compilazione, che usa le opzioni del compilatore coerente, i pragma e così via, che avevano al momento della creazione del file PCH, se non diversamente specificato.When you use a PCH file, the compiler assumes the same compilation environment — one that uses consistent compiler options, pragmas, and so on — that was in effect when you created the PCH file, unless you specify otherwise. Se il compilatore rileva un'incoerenza, genera un avviso e lo identifica l'incoerenza laddove possibile.If the compiler detects an inconsistency, it issues a warning and identifies the inconsistency where possible. Questi avvisi non indicano necessariamente un problema con il file PCH. essi avvisa semplicemente di possibili conflitti.Such warnings do not necessarily indicate a problem with the PCH file; they simply warn you of possible conflicts. Nelle sezioni seguenti sono descritti i requisiti di coerenza per PCH (file).Consistency requirements for PCH files are described in the following sections.

Coerenza di opzione del compilatoreCompiler Option Consistency

Le seguenti opzioni del compilatore possono attivare un avviso di incoerenza quando si utilizza un file PHC:The following compiler options can trigger an inconsistency warning when using a PCH file:

  • Le macro create mediante il preprocessore (/ D) opzione deve essere lo stesso tra la compilazione che ha creato il file PCH e la compilazione corrente.Macros created using the Preprocessor (/D) option must be the same between the compilation that created the PCH file and the current compilation. Non viene controllato lo stato delle costanti definite, ma possono verificarsi risultati imprevisti se queste sono modificate.The state of defined constants is not checked, but unpredictable results can occur if these change.

  • PCH (file) non funzionano con le opzioni /E e /EP.PCH files do not work with the /E and /EP options.

  • PCH (file) devono essere creati usando uno Generate Browse Info (/ FR) opzione o le variabili locali escludere (o Fr) opzione prima che le successive compilazioni che utilizzano il file PCH è possono utilizzare queste opzioni.PCH files must be created using either the Generate Browse Info (/FR) option or the Exclude Local Variables (/Fr) option before subsequent compilations that use the PCH file can use these options.

Compatibile C 7.0 (/ Z7)C 7.0-Compatible (/Z7)

Se questa opzione è attiva quando viene creato il file PCH, le successive compilazioni che utilizzano il file PCH possono utilizzare le informazioni di debug.If this option is in effect when the PCH file is created, subsequent compilations that use the PCH file can use the debugging information.

Se il compatibile C 7.0 (/ Z7) opzione non è attiva quando viene creato il file PCH, le successive compilazioni che utilizzano il file PCH /Z7 generano un avviso.If the C 7.0-Compatible (/Z7) option is not in effect when the PCH file is created, subsequent compilations that use the PCH file and /Z7 trigger a warning. Le informazioni di debug viene inserite nel file obj corrente e i simboli locali definiti nel file PCH non sono disponibili per il debugger.The debugging information is placed in the current .obj file, and local symbols defined in the PCH file are not available to the debugger.

Includere la coerenza di percorsoInclude Path Consistency

Un file PHC non contiene informazioni sul percorso di inclusione che avevano al momento della creazione.A PCH file does not contain information about the include path that was in effect when it was created. Quando si utilizza un file PCH, il compilatore Usa sempre il percorso di inclusione specificato nella compilazione corrente.When you use a PCH file, the compiler always uses the include path specified in the current compilation.

Coerenza di File di origineSource File Consistency

Quando si specifica l'opzione di utilizzo File di intestazione precompilata (/Yu), il compilatore ignora tutte le direttive del preprocessore (inclusi i pragma) presenti nel codice sorgente che verrà precompilato.When you specify the Use Precompiled Header File (/Yu) option, the compiler ignores all preprocessor directives (including pragmas) that appear in the source code that will be precompiled. La compilazione specificata dalle direttive del preprocessore deve essere identico dalla compilazione per l'opzione Creazione precompilate intestazione File (/Yc).The compilation specified by such preprocessor directives must be the same as the compilation used for the Create Precompiled Header File (/Yc) option.

Coerenza (pragma)Pragma Consistency

I pragma elaborati durante la creazione di un file PHC in genere influisce sul file con cui viene successivamente utilizzato il file PCH.Pragmas processed during the creation of a PCH file usually affect the file with which the PCH file is subsequently used. Il comment e message pragma non influiscono sul resto della compilazione.The comment and message pragmas do not affect the remainder of the compilation.

Questi pragma interessano solo il codice all'interno del file PCH; non influiscono sul codice che viene successivamente utilizzato il file PCH:These pragmas affect only the code within the PCH file; they do not affect code that subsequently uses the PCH file:

comment page subtitle
linesize pagesize title
message skip

Questi pragma vengono mantenuti come parte di un'intestazione precompilata e influiscono sul resto di una compilazione che utilizza l'intestazione precompilata:These pragmas are retained as part of a precompiled header, and affect the remainder of a compilation that uses the precompiled header:

alloc_text include_alias pack
auto_inline init_seg pointers_to_members
check_stack inline_depth setlocale
code_seg inline_recursion vtordisp
data_seg intrinsic warning
function optimize

Regole di uniformità per /Yc e /YuConsistency Rules for /Yc and /Yu

Quando si utilizza un'intestazione precompilata creata con /Yc o /Yu, il compilatore confronta l'ambiente di compilazione corrente a quella esistente al momento della creazione del file PCH.When you use a precompiled header created using /Yc or /Yu, the compiler compares the current compilation environment to the one that existed when you created the PCH file. Assicurarsi di specificare un ambiente coerenza con quella precedente (utilizzando le opzioni del compilatore coerente, i pragma e così via) per la compilazione corrente.Be sure to specify an environment consistent with the previous one (using consistent compiler options, pragmas, and so on) for the current compilation. Se il compilatore rileva un'incoerenza, genera un avviso e lo identifica l'incoerenza laddove possibile.If the compiler detects an inconsistency, it issues a warning and identifies the inconsistency where possible. Questi avvisi non indicano necessariamente un problema con il file PCH. essi avvisa semplicemente di possibili conflitti.Such warnings don't necessarily indicate a problem with the PCH file; they simply warn you of possible conflicts. Le sezioni seguenti illustrano i requisiti di coerenza per le intestazioni precompilate.The following sections explain the consistency requirements for precompiled headers.

Coerenza di opzione del compilatoreCompiler Option Consistency

Questa tabella elenca le opzioni del compilatore potrebbero generare un avviso di incoerenza quando si utilizza un'intestazione precompilata:This table lists compiler options that might trigger an inconsistency warning when using a precompiled header:

OpzioneOption nomeName RegolaRule
/D/D Definire le costanti e macroDefine constants and macros Deve essere lo stesso tra la compilazione che ha creato l'intestazione precompilata e la compilazione corrente.Must be the same between the compilation that created the precompiled header and the current compilation. Non viene controllato lo stato delle costanti definite, ma possono verificarsi risultati inattesi se i file dipendono dai valori delle costanti modificate.The state of defined constants is not checked, but unpredictable results can occur if your files depend on the values of the changed constants.
/E o /EP/E or /EP Copia l'output del preprocessore output standardCopy preprocessor output to standard output Le intestazioni precompilate non funzionano con l'opzione /E o /EP.Precompiled headers do not work with the /E or /EP option.
/FR o /FR/Fr or /FR Genera informazioni di Microsoft Source BrowserGenerate Microsoft Source Browser information Per le opzioni essere valido con l'opzione /Yu and /Fr, essi devono anche essere stati attiva quando è stato creato l'intestazione precompilata.For the /Fr and /FR options to be valid with the /Yu option, they must also have been in effect when the precompiled header was created. Le successive compilazioni che utilizzano l'intestazione precompilata inoltre generano informazioni di visualizzazione di origine.Subsequent compilations that use the precompiled header also generate Source Browser information. Informazioni di visualizzazione viene inserite in un unico file sbr e viene fatto riferimento da altri file nello stesso modo come informazioni di CodeView.Browser information is placed in a single .sbr file and is referenced by other files in the same manner as CodeView information. Non è possibile ignorare la posizione delle informazioni di visualizzazione di origine.You cannot override the placement of Source Browser information.
/ /GD, GA, /GE, /Gw o /GW/GA, /GD, /GE, /Gw, or /GW Opzioni del protocollo di WindowsWindows protocol options Deve essere lo stesso tra la compilazione che ha creato l'intestazione precompilata e la compilazione corrente.Must be the same between the compilation that created the precompiled header and the current compilation. Se queste opzioni sono diversi, verrà generato un messaggio di avviso.If these options differ, a warning message results.
/ZI/Zi Genera informazioni di debug completeGenerate complete debugging information Se questa opzione è attiva quando viene creato l'intestazione precompilata, le successive compilazioni che utilizzano la precompilazione possono utilizzare le informazioni di debug.If this option is in effect when the precompiled header is created, subsequent compilations that use the precompilation can use that debugging information. Se /Zi non è attiva quando viene creato l'intestazione precompilata successive compilazioni che utilizzano la precompilazione e l'opzione /Zi. generano un avviso.If /Zi is not in effect when the precompiled header is created, subsequent compilations that use the precompilation and the /Zi option trigger a warning. Le informazioni di debug viene inserite nel file oggetto corrente e i simboli locali definiti nell'intestazione precompilata non sono disponibili per il debugger.The debugging information is placed in the current object file, and local symbols defined in the precompiled header are not available to the debugger.

Nota

La funzionalità di intestazione precompilata deve essere utilizzato solo nei file di origine C e C++.The precompiled header facility is intended for use only in C and C++ source files.

Utilizzo di intestazioni precompilate in un progettoUsing Precompiled Headers in a Project

Nelle sezioni precedenti presentano una panoramica delle intestazioni precompilate: /Yc e /Yu, l'opzione /Fp e hdrstop pragma.Previous sections present an overview of precompiled headers: /Yc and /Yu, the /Fp option, and the hdrstop pragma. In questa sezione viene descritto un metodo per l'utilizzo delle opzioni di intestazione precompilata manuale in un progetto. che termina con un makefile di esempio e il codice che gestisce.This section describes a method for using the manual precompiled-header options in a project; it ends with an example makefile and the code that it manages.

Per un altro approccio per l'utilizzo delle opzioni di intestazione precompilata manuale in un progetto, esaminare uno dei makefile presenti nella directory MFC\SRC che viene creata durante l'installazione predefinita di Visual C++.For another approach to using the manual precompiled-header options in a project, study one of the makefiles located in the MFC\SRC directory that is created during the default setup of Visual C++. I makefile adottano un approccio simile a quello presentato in questa sezione maggiore utilizzo di macro NMAKE Microsoft Program Maintenance Utility () ma offrono un maggiore controllo del processo di compilazione.These makefiles take a similar approach to the one presented in this section but make greater use of Microsoft Program Maintenance Utility (NMAKE) macros, and offer greater control of the build process.

File PCH nel processo di compilazionePCH Files in the Build Process

La base di codice di un progetto software è contenuta generalmente in più C o C++ i file di origine, file oggetto, librerie e file di intestazione.The code base of a software project is usually contained in multiple C or C++ source files, object files, libraries, and header files. In genere, un makefile coordina la combinazione di questi elementi in un file eseguibile.Typically, a makefile coordinates the combination of these elements into an executable file. Nella figura seguente mostra la struttura di un makefile che utilizza un file di intestazione precompilata.The following figure shows the structure of a makefile that uses a precompiled header file. I nomi di macro NMAKE e i nomi dei file in questo diagramma sono coerenti con quelli nel codice di esempio nel Makefile di esempio per PCH e codice di esempio per PCH.The NMAKE macro names and the file names in this diagram are consistent with those in the example code found in Sample Makefile for PCH and Example Code for PCH.

Nella figura utilizza tre motivi grafici per visualizzare il flusso del processo di compilazione.The figure uses three diagrammatic devices to show the flow of the build process. Denominato rappresentano i rettangoli ogni file o una macro. le tre macro rappresentano uno o più file.Named rectangles represent each file or macro; the three macros represent one or more files. Le aree ombreggiate rappresentano ogni azione di compilazione o di collegamento.Shaded areas represent each compile or link action. Le frecce indicano quali file e le macro vengono combinate durante la compilazione o di un processo di collegamento.Arrows show which files and macros are combined during the compilation or linking process.

Makefile che utilizza un file di intestazione precompilataMakefile that uses a precompiled header file

Struttura di un makefile che utilizza un file di intestazione precompilataStructure of a Makefile That Uses a Precompiled Header File

A partire dalla parte superiore del diagramma, STABLEHDRS sia confine AS sono macro NMAKE in cui sono elencati i file probabilmente non devono essere ricompilati.Beginning at the top of the diagram, both STABLEHDRS and BOUNDRY are NMAKE macros in which you list files not likely to need recompilation. Questi file vengono compilati dalla stringa di comandoThese files are compiled by the command string

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

solo se il file di intestazione precompilata (Stable. pch) non esiste o se si apportano modifiche ai file elencati nelle due macro.only if the precompiled header file (STABLE.pch) does not exist or if you make changes to the files listed in the two macros. In entrambi i casi, il file di intestazione precompilata contengono codice solo dai file elencati nella macro STABLEHDRS.In either case, the precompiled header file will contain code only from the files listed in the STABLEHDRS macro. Elencare l'ultimo file desiderato precompilato nella macro confine AS.List the last file you want precompiled in the BOUNDRY macro.

I file elencati in queste macro possono essere file di intestazione o il file di origine C o C++.The files you list in these macros can be either header files or C or C++ source files. (Impossibile utilizzare un unico file PCH con moduli C++ e C). Si noti che è possibile utilizzare il hdrstop macro per interrompere la precompilazione a un certo punto all'interno del file di confine AS.(A single PCH file cannot be used with both C and C++ modules.) Note that you can use the hdrstop macro to stop precompilation at some point within the BOUNDRY file. Vedere hdrstop per ulteriori informazioni.See hdrstop for more information.

Continuare premuto nel diagramma, APPLIB rappresenta il codice di supporto utilizzato nell'applicazione finale.Continuing down the diagram, APPLIB.obj represents the support code used in your final application. Viene creata da APPLIB, i file elencati nella macro UNSTABLEHDRS e del codice precompilato da intestazione precompilata.It is created from APPLIB.cpp, the files listed in the UNSTABLEHDRS macro, and precompiled code from the precompiled header.

MyApp rappresenta finale dell'applicazione.MYAPP.obj represents your final application. Viene creata da MyApp. cpp, i file elencati nella macro UNSTABLEHDRS e del codice precompilato da intestazione precompilata.It is created from MYAPP.cpp, the files listed in the UNSTABLEHDRS macro, and precompiled code from the precompiled header.

Infine, il file eseguibile (MYAPP. Con estensione EXE) viene creato collegando i file elencati nella macro OBJS (APPLIB e MyApp).Finally, the executable file (MYAPP.EXE) is created by linking the files listed in the OBJS macro (APPLIB.obj and MYAPP.obj).

Makefile di esempio per PCHSample Makefile for PCH

Il seguente file di progetto usa macro e un oggetto. SE! ALTRO! Struttura del flusso di controllo comando ENDIF che semplifica l'adattamento al progetto.The following makefile uses macros and an !IF, !ELSE, !ENDIF flow-of-control command structure to simplify its adaptation to your project.

# 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 = /NOD /ONERROR:NOEXE  
!IF "$(DEBUG)" == "1"  
CLFLAGS   = /D_DEBUG $(CLFLAGS) /Od /Zi /f  
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  

A parte le macro STABLEHDRS confine AS e UNSTABLEHDRS illustrate nella figura "Struttura di un Makefile che utilizza un precompilata File di intestazione" in file PCH nel processo di compilazione, questo makefile fornisce contiene due macro e un LINKFLAGS macro.Aside from the STABLEHDRS, BOUNDRY, and UNSTABLEHDRS macros shown in the figure "Structure of a Makefile That Uses a Precompiled Header File" in PCH Files in the Build Process, this makefile provides a CLFLAGS macro and a LINKFLAGS macro. È necessario utilizzare queste macro per visualizzare l'elenco di opzioni del compilatore e del linker che si applicano se si compila una versione di debug o finale del file eseguibile dell'applicazione.You must use these macros to list compiler and linker options that apply whether you build a debug or final version of the application's executable file. È inoltre disponibile una macro di librerie in cui vengono elencati le librerie richiede il progetto.There is also a LIBS macro where you list the libraries your project requires.

Utilizza inoltre il file di progetto. SE! ALTRO! ENDIF per rilevare se si definisce un simbolo DEBUG nella riga di comando NMAKE:The makefile also uses !IF, !ELSE, !ENDIF to detect whether you define a DEBUG symbol on the NMAKE command line:

NMAKE DEBUG=[1|0]  

Questa funzionalità rende possibile per poter utilizzare lo stesso makefile durante lo sviluppo e per le versioni finali del programma, utilizzare DEBUG = 0 per le versioni finali.This feature makes it possible for you to use the same makefile during development and for the final versions of your program — use DEBUG=0 for the final versions. Le righe di comando seguenti sono equivalenti:The following command lines are equivalent:

NMAKE   
NMAKE DEBUG=0  

Per ulteriori informazioni sui makefile, vedere riferimenti a NMAKE.For more information on makefiles, see NMAKE Reference. Vedere anche opzioni del compilatore e opzioni del Linker.Also see Compiler Options and the Linker Options.

Codice di esempio per PCHExample Code for PCH

I seguenti file di origine vengono utilizzati in makefile illustrato in file PCH nel processo di compilazione e Makefile di esempio per PCH.The following source files are used in the makefile described in PCH Files in the Build Process and Sample Makefile for PCH. Si noti che i commenti che contengono importanti informazioni.Note that the comments contain important information.

// 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  
// 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  
// 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.h>  
void notstable( void );  
#endif // __UNSTABLE_H  
// 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"  
// 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"; 
    }  
// 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();  
}  

Vedere ancheSee Also

C/C++ Building Reference (Informazioni di riferimento per la compilazione in C/C++)C/C++ Building Reference
Opzioni del compilatoreCompiler Options