Perché utilizzare le intestazioni precompilate (C/C++)?

Question

Domanda veloce - Perché utilizzare le intestazioni precompilate?

EDIT: Leggendo le risposte, ho il sospetto che quello che ho fatto con loro è un pò stupido:

#pragma once 

//Defines used for production versions 

#ifndef PRODUCTION 
#define eMsg(x) (x) //Show error messages 
#define eAsciiMsg(x) (x) 
#else 
#define eMsg(x) (L"") //Don't show error messages 
#define eAsciiMsg(x) ("") 
#endif //PRODUCTION 

#include "targetver.h" 
#include "version.h" 

//Enable "unsafe" but much faster string functions 
#define _CRT_SECURE_NO_WARNINGS 
#define _SCL_SECURE_NO_WARNINGS 

//Standard Includes 
#include <stdio.h> 
#include <tchar.h> 
#include <iostream> 
#include <direct.h> 
#include <cstring> 
#ifdef _DEBUG 
#include <cstdlib> 
#endif 

//Standard Template Library 
#include <bitset> 
#include <vector> 
#include <list> 
#include <algorithm> 
#include <iterator> 
#include <string> 
#include <numeric> 

//BOOST libraries 
#include <boost/algorithm/string.hpp> 
#include <boost/lexical_cast.hpp> 
#include <boost/scoped_array.hpp> 

//Windows Includes 
#define WIN32_LEAN_AND_MEAN 
#include <windows.h> 
#include "FILETIME_Comparisons.h" 
#include <shlwapi.h> 
#include <Shellapi.h> 
#include <psapi.h> 
#include <imagehlp.h> 
#include <mscat.h> 
#include <Softpub.h> 
#include <sfc.h> 
#pragma comment(lib, "wintrust.lib") 
#pragma comment(lib,"kernel32.lib") 
#pragma comment(lib,"Psapi.lib") 
#pragma comment(lib,"shlwapi.lib") 
#pragma comment(lib,"imagehlp.lib") 
#pragma comment(lib,"Advapi32.lib") 
#pragma comment(lib,"Shell32.lib") 
#pragma comment(lib,"Sfc.lib") 
#pragma comment(lib,"Version.lib") 

//Crypto ++ Libraries 
#ifdef _DEBUG 
#pragma comment(lib,"cryptlibd.lib") 
#else 
#pragma comment(lib,"cryptlib.lib") 
#endif 
#define CRYPTOPP_ENABLE_NAMESPACE_WEAK 1 
#include <md5.h> 
#include <sha.h> 

//String libraries 
#include "stringUnicodeConversions.h" 
#include "expandEnvStrings.h" 
#include "randomString.h" 
#include "getShortPathName.h" 

//Regular Expression Libraries 
#include "fpattern.h" 

//File Result Record 
#include "unixTimeToFileTime.h" 
#include "fileData.h" 

//Writer 
#include "writeFileData.h" 

//Criteria Structure System 
#include "priorities.h" 
#include "criterion.H" 
#include "OPSTRUCT.H" 
#include "regexClass.H" 
#include "FILTER.h" 

//Sub Programs Root Class 
#include "subProgramClass.h" 

//Global data 
#include "globalOptions.h" 

//Logger 
#include "logger.h" 

//Console parser 
#include "consoleParser.h" 

//Timeout handler 
#include "timeoutThread.h" 

//Zip library 
#include "zip.h" 
#include "unzip.h" 
#include "zipIt.h" 

//Scanner 
#include "mainScanner.h" 
#include "filesScanner.h" 

//Sub Programs 
#include "volumeEnumerate.h" 
#include "clsidCompressor.h" 
#include "times.h" 
#include "exec.h" 
#include "uZip.h" 

//64 Bit support 
#include "disable64.h" 

Answer 1

Compila molto MOLTO più veloce. La compilazione C++ richiede anni senza di loro. Prova a confrontare a volte in un grande progetto!

Answer 2

Quindi non c'è bisogno di compilare ogni volta che si genera il progetto. Sono usati per le intestazioni di sistema che non cambieranno.

Answer 3

Accelera la compilazione.

Quando includi intestazioni di altri progetti, non ti aspetti di cambiarle. Se li inserisci in un'intestazione precompilata, quel codice non dovrà essere ricompilato quando apporti modifiche al tuo codice sorgente. Questo riduce la compilazione ripetitiva di codice invariato, accelerando il tempo di compilazione.

Answer 4

In C/C++, il meccanismo di inclusione # è una copia testuale del file specificato nel file corrente. Le intestazioni includono altre intestazioni (che includono ancora altre intestazioni), quindi quando si esegue #include, è possibile aggiungere decine di migliaia di righe di C++ in ogni file cpp (o cxx, c, qualunque), che devono essere tutti compilato ogni volta. Questo può essere un grave collo di bottiglia per progetti di grandi dimensioni.

intestazioni precompilate accelerare l'operazione mediante la compilazione di ogni intestazione una volta, quindi compreso quello stato compilato nel cpp sono inclusi nella

Answer 5

Re:. L'uso corrente, se si dispone di un bersaglio con un gran numero di file , potrebbe essere ancora più veloce usare PCH in questo modo - prova a spegnerli per scoprirlo. Dipende: se hai molte intestazioni personali e le cambi solo di rado, e hai un numero molto elevato di file sorgente che cambi molto più spesso, l'utilizzo del PCH ridurrà i tempi di ricostruzione.

Ma il normale consiglio è di inserire solo cose in PCH che non cambiano mai, perché c'è un certo overhead per produrre il PCH stesso. Se lo si attiva con ogni ricostruzione (modificando costantemente uno degli header), l'uso di PCH potrebbe rallentare la ricostruzione.