Why use Precompiled Headers (C/C++)?

Question

Hello all :)

Quick question -- Why use Precompiled Headers?

Billy3

EDIT: Reading the responses, I suspect what I've been doing with them is kinda stupid:

 #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

So you don't have to compile them every time you build your project. They're used for system headers that aren't going to change.

Answer 2

It compiles a LOT quicker. C++ compilation takes years without them. Try comparing sometime in a large project!

Answer 3

It speeds up compilation.

When you're including headers from other projects, you don't expect to change them. If you put these into a precompiled header, then that code will not have to be recompiled when you make changes to your source code. This reduces repetitive compilation of unchanged code, speeding up compile time.

Answer 4

In C/C++, the #include mechanism is a textual copy of the file specified into the current file. Headers include other headers (which include yet other headers), so when you do a #include, it could be adding tens of thousands of lines of C++ into each cpp file (or cxx, c, whatever), all of which need to be compiled each time. This can be a sever bottleneck for large projects.

Precompiled headers speed this up by compiling each header once, then including that compiled state into the cpp they are included in.

Answer 5

Re: your current usage, if you have a target with a very large number of files, it may still be faster to use PCH in that way - try switching them off to find out. It depends: if you have a lot of headers of your own, and you change them only infrequently, and you have a very large number of source files that you change much more frequently, then your PCH usage will cut rebuild times.

But normal advice is to only put things in PCH that never change, because there is a certain overhead to producing the PCH itself. If you trigger that off with every rebuild (by constantly tweaking one of your headers), using PCH may make the rebuild slower.