在C ++中包含双头？

Question

I have what seems a relatively simple question, but one that keeps defying my efforts to understand it.

I apologise if it is a simple question, but like many simple questions, I can't seem to find a solid explanation anywhere.

With the below code:

/*foo.c*/

#include "bar.h"

int main() {
   return(my_function(1,2));
}

/*bar.h*/

int my_function(int,int);

/*bar.c*/

#include "bar.h" /*is this necessary!?*/

int my_function(int x, int y) {
    return(x+y);
}

Simply, is the second inclusion necessary? I don't understand why I keep seeing headers included in both source files. Surely if the function is declared in "foo.c" by including "bar.h," it does not need to be declared a second time in another linked source file (especially the one which actually defines it)??? A friend tried to explain to me that it didn't really matter for functions, but it did for structs, something which still eludes me! Help!

Is it simply for clarity, so that programmers can see which functions are being used externally?

I just don't get it!

Thanks!

Answer 1

In this particular case, it's unnecessary for the reason you described. It might be useful in situations where you have a more complex set of functions that might all depend on each other. If you include the header at the top of the .cpp file, you have effectively forward-declared every single function and so you don't have to worry about making sure your function definitions are in a certain order.

I also find that it clearly shows that these function definitions correspond to those declarations. This makes it easier for the reader to find how translation units depend on each other. Of course, the names of the files might be sufficient, but some more complex projects do not have one-to-one relationship between .cpp files and .h files. Sometimes headers are broken up into multiple parts, or many implementation files will have their external functions declared in a single header (common for large modules).

Really, all inclusions are unnecessary. You can always, after all, just duplicate the declarations (or definitions, in the case of classes) across all of the files that require them. We use the preprocessor to simplify this task and reduce the amount of redundant code. It's easier to stick to a pattern of always including the corresponding header because it will always work, rather than have to check each file every time you edit them and determine if the inclusion is necessary or not.

Answer 2

The way the C language (and C++) is designed is that the compiler processes each .c file in isolation.

You typically launch your compiler (cl.exe or gcc, for example) for one of your c files, and this produces one object file (.o or .obj).

Once all your object files have been generated, you run the linker, passing it all the object files, and it will tie them together into an executable.

That's why every .c file needs to include the headers it depends on. When the compiler is processing it, it knows nothing about which other .c files you may have. All it knows is the contents of the .c file you point it to, as well as the headers it includes.

Answer 3

Simple rule is this(Considering foo is a member function of some class):-

So, if some header file is declaring a function say:=

//foo.h
void foo (int x);

Compiler would need to see this declaration anywhere you have defined this function ( to make sure your definition is in line with declaration) and you are calling this function ( to make sure you have called the function with correct number and type of arguments).

That means you have to include foo.h everywhere you are making call to that function and where you are providing definition for that function.

Also if foo is a global function ( not inside any namespace ) then there is no need to include that foo.h in implementation file.

Answer 4

In your simplified example inclusion of "bar.h" in "bar.c" is not necessary. But in real world in most cases it would be. If you have a class declaration in "bar.h", and "bar.c" has functions of this class, the inclusion is needed. If you have any other declaration which is used in "bar.c" - being it a constant, enum, etc. - again include is needed. Because in real world it is nearly always needed, the easy rule is - include the header file in the corresponding source file always.

Answer 5

If the header only declares global functions, and the source file only implements them (without calling any of them) then it's not strictly necessary. But that's not usually the case; in a large program, you rarely want global functions.

If the header defines a class, then you'll need to include it in the source file in order to define member functions:

void Thing::function(int x) {
   //^^^^^^^ needs class definition
}

If the header declares functions in a namespace, then it's a good idea to put the definitions outside the namespace:

void ns::function(int x) {
   //^^^^ needs previous declaration
}

This will give a nice compile-time error if the parameter types don't match a previous declaration - for which you'd need to include the header. Defining the function inside its namespace

namespace ns {
    void function(int x) {
        // ...
    }
}

will silently declare a new overload if you get the parameter types wrong.