Why including same headers in multiple cpp files and then their compilation works? [duplicate]

Question

This question already has an answer here:

• One definition rule and different class definitions in two translation units 1 answer

For example I have 2 cpp files: f1.cpp and f2.cpp, and also a header file: xxx.h.

f1.cpp has the following source code:

#include <iostream>
#include "xxx.h"

using namespace std;

int main ()
{
    rect rplace;
    polar pplace;
    cout<<"Enter the x and y values: ";
    while (cin>>rplace.x>>rplace.y)
    {
        pplace=rect_to_polar(rplace);
        show_polar(pplace);
        cout<<"Next two numbers (q to quit): ";
    }
    cout<<"Done.\n";
    return 0;
}

f2.cpp source code:

#include <iostream>
#include <cmath>
#include "xxx.h"

polar rect_to_polar (rect xypos)
{
    using namespace std;
    polar answer;
    answer.distance=sqrt(xypos.x*xypos.x+xypos.y*xypos.y);
    answer.angle=atan2(xypos.y, xypos.x);
    return answer;
} 

void show_polar (polar dapos)
{
    using namespace std;
    const double Rad_to_deg=57.29577951;
    cout<<"distance="<<dapos.distance;
    cout<<", angle= "<<dapos.angle*Rad_to_deg;
    cout<<"degrees\n";
}

And xxx.h:

struct polar
{
    double distance;
    double angle;
};

struct rect
{
    double x;
    double y;
};

polar rect_to_polar (rect xypos);
void show_polar(polar dapos);

I thought that there should be a compiler error because the headers xxx.h and iostream are included two times: once in f1.cpp and once in f2.cpp. But everything was compiled, so I don't understand how it can work.

Answer 1

The preprocessor simply reads the header files and puts them into the translation units where the #include directive is. If one header file is included in one source file, only that file knows about the declarations in that header file.

You also should know the difference between declarations and definitions. When you declare something, you just tells the compiler that "this thing exists and is of type this-and-that". When you define something, you tell the compiler "this is the thing I declared before".

You can have multiple declarations of the same thing. because they only act as meta-data for the compiler, and are not used outside its translation unit. You can however only have one definition of something. That's why you can't define global variables/functions in header files included in multiple source files.

Also, In this answer I talk about "source files", "header files" and "translation units". Header files are the files you #include. Source files is the files that does the including (so to speak). And a translation unit is the complete preprocessed source, complete with the source and all included header files, and which is passed on to the actual compiler.