Pourquoi utiliser les en-têtes précompilés (C/C++)?

Question

Question rapide - Pourquoi utiliser les en-têtes précompilés?

EDIT: La lecture des réponses, je soupçonne que ce que je fais avec eux est un peu stupide:

#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

Il compile beaucoup plus rapidement. La compilation C++ prend des années sans eux. Essayez de comparer parfois dans un grand projet!

Answer 2

Vous n'avez pas à les compiler chaque fois que vous construisez votre projet. Ils sont utilisés pour les en-têtes système qui ne vont pas changer.

Answer 3

Cela accélère la compilation.

Lorsque vous incluez des en-têtes d'autres projets, vous ne prévoyez pas de les modifier. Si vous les mettez dans un en-tête précompilé, ce code n'aura pas à être recompilé lorsque vous apportez des modifications à votre code source. Cela réduit la compilation répétitive du code inchangé, ce qui accélère le temps de compilation.

Answer 4

En C/C++, le mécanisme #include est une copie textuelle du fichier spécifié dans le fichier en cours. Les en-têtes incluent d'autres en-têtes (qui incluent encore d'autres en-têtes), donc quand vous faites un #include, cela pourrait ajouter des dizaines de milliers de lignes de C++ dans chaque fichier cpp (ou cxx, c, peu importe). compilé à chaque fois. Cela peut être un goulot d'étranglement pour les grands projets.

têtes précompilés accélèrent cela en compilant chaque en-tête une fois, y compris alors que l'état compilé dans le cpp, ils sont inclus dans

Answer 5

Re:. Votre utilisation actuelle, si vous avez une cible avec un très grand nombre de fichiers , il peut être encore plus rapide d'utiliser PCH de cette façon - essayez de les éteindre pour le savoir. Cela dépend: si vous avez beaucoup d'en-têtes et que vous les changez rarement, et que vous avez un très grand nombre de fichiers sources que vous changez beaucoup plus fréquemment, votre utilisation de PCH réduira les temps de reconstruction.

Mais le conseil normal est de ne mettre que les choses dans PCH qui ne changent jamais, parce qu'il y a un certain surcoût pour produire le PCH lui-même. Si vous le déclenchez à chaque reconstruction (en modifiant constamment l'un de vos en-têtes), l'utilisation de PCH peut ralentir la reconstruction.