链接阶段的#include 指令

Question

A header file usually has some safe guard using the #ifndef directives(or similar) eg:

//header.hpp
#ifndef HEADER
#define HEADER
//code
#endif  

but, I have a confusion here, what if we do the following(consider the two file's source codes):

//file1.cpp
#include "header.hpp"
//somecode  

and the file

//file2.cpp
#include "header.hpp"
//somecode  

if we did something like this:

g++ file1.cpp file2.cpp -o mainfile  

we'd get a single executable that would get a single executable with no duplication since the includes are checked at compile time.

But, what if we do:

g++ -c file1.cpp -o file1.o
g++ -c file2.cpp -o file2.o
g++ file1.o file2.o -o mainfile.o

What happens during the linking stage? Will the includes have conflict? What happens to the includes during the compile time? Does it get duplicated? What is the mechanism under the hood to deal with this at this stage?

Answer 1

Normally a header file only contains function and variable declarations, and not their definitions. It's the definitions which are processed by the linking stage, so one can include a header many times in different source files and the linker just won't see anything. If you do have a global function or variable definition in a header file, you will get a linker error.

Answer 2

The formal term here is "Translation Unit". That's what you call a single .cpp file with all the headers included by it. Preprocessor definitions do not span Translation Units, and you have two Translation Units here. The linking process is what combines Tranlation Units, but at that phase the preprocessor is long done.

Answer 3

Both are exactly the same. The Guard doesn't go to the next file. Every file is compiled with new #define - state.

Answer 4

#include is actually a preprocessor-directive, which means, they are resolved before compilation. The preprocessor processes every translation unit seperately and two translation units do not influence each other. The results of this step don't contain any preprocessor statements (like #include , #ifdef , #define , etc).

So after preprocessing, both files, file1.cpp and file2.cpp , contain the contents of header.hpp . Then both are compiled to file1.o and file2.o . No problems so far. Here comes the importance of include guards. Compilation will fail if a translation unit contains duplicate declarations.

Imagine you got a header1.hpp :

#include "header.hpp"

class ABC { ... };

And header2.hpp :

#include "header.hpp"

class XYZ { ... };

And some file, say, file3.cpp would rely on both:

#include "header1.hpp"
#include "header2.hpp"

class Foo : pulbic ABC, public XYZ {};

Without include guards you end end with including header.hpp twice and get all the declarations twice in the translation unit, which doesn't compile. (We are only looking at file3.cpp here). With include guards header.hpp is only included once .

Now we finally reached the linking stage and come back to your original example. You have 2 compilation units, that both contain all the decalrations from header.hpp . The linker will not care about duplicate declarations. The linker will only fail if it finds multiple definitions of a symbol.

The #include s are not "checked" or "ignored" at the linking stage, they simply don't exist any more.