How do header files and makefiles help incremental compilation in c++?

Question

I understand what incremental compilation is: when a compiler only compiles the code you edited not all of it. But how does separating code into .h and .c/.cc files, and makefiles in C++ help incremental compilation?

Answer 1

Header files are actually counter productive to incrementality of compilation. Any change to any header will cause all source files which include the header (even indirectly through another header) to be re-compiled. But headers make it much, much easier to keep all definitions identical - as is required by the language - across multiple translation units, so their use is virtually necessary. This counter productivity is the reason why "include only what you need" is a rule of thumb to consider.

What does help incremental compilation is simply having less definitions per translation unit. If you write your entire program in a single source file, then what ever tiny change to any small part of the program will cause the need for entire program to be re-compiled.

If you instead write every single function in a separate source file, then modification to any of those functions will cause the need for only that tiny source file to be recompiled, and then linked together with the unmodified previously compiled object files. Compiling a single function is generally faster than compiling an entire program. Although, if the change is for example to the arguments of a function, then everything that calls the function - i.e. its dependees - must also be recompiled (so, this would be a case where the change is in a header file, and all dependees must have included the header).

Another advantage of having multiple source files is that they can be compiled independently and thus in parallel, which is great given the multi-core processors of today, not to mention data centers with endless rows of computer systems. There are disadvantages too though: Non-incremental compilation from scratch is generally more expensive when there are many inline functions (which notably includes all templates), which need to be recompiled for each separate source file that use them.

Build systems such as make and ninja are tools which among their other features, keep track of previously compiled source files, and do the work of deciding which of the source files require re-compilation after modification. The decision is typically based on modification time of the source file (and all included files) compared to its compiled object file.

---

This all applies to using a "dumb" non-incremental compiler (which is most compilers) that require a build tool to filter the needed re-compilations and don't have any incremental logic within them. For a truly incremental compiler, build systems and potentially even translation unit divisions might not be necessary.