web-dev-qa-db-fra.com

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

Pourquoi utiliser des en-têtes précompilés?

En lisant les réponses, je soupçonne que ce que j'ai fait 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"
c++precompiled-headers
45
Billy ONeal

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

41
rlbond

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

Les en-têtes précompilés accélèrent cela en compilant une fois chaque en-tête, puis en incluant cet état compilé dans le cpp dans lequel ils sont inclus.

56
Todd Gardner

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

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

10
Daniel Earwicker

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

7
n8gray

Cela accélère la compilation.

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

7
swongu