C源文件的好处包括它自己的头文件

Question

I understand that if a source file need to reference functions from other file then it needs to include its header file, but I don't understand why the source file include its own header file. Content in header file is simply being copied and pasted into the source file as function declarations in per-processing time. For source file who include its own header file, such "declaration" doesn't seem necessary to me, in fact, project still compile and link no problem after remove the header from it's source file, so what's the reason for source file include its own header?

Answer 1

The main benefit is having the compiler verify consistency of your header and its implementation. You do it because it is convenient, not because it is required. It may definitely be possible to get the project to compile and run correctly without such inclusion, but it complicates maintenance of your project in the long run.

If your file does not include its own header, you can accidentally get in a situation when forward declaration of a function does not match the definition of the function - perhaps because you added or removed a parameter, and forgot to update the header. When this happens, the code relying on the function with mismatch would still compile, but the call would result in undefined behavior. It is much better to have the compiler catch this error, which happens automatically when your source file includes its own header.

Answer 2

The header file tells people what the source file can do.

So the source file for the header file needs to know its obligations. That is why it is included.

Answer 3

Yours seems a borderline case, but an include file can be viewed as a sort of contract between that source file and any other source files that may require those functions.

By writing the "contract" in a header file, you can ensure that the other source files will know how to invoke those functions, or, rather, you will be sure that the compiler will insert the correct code and check its validity at compile time.

But what if you then (even inadvertently) changed the function prototype in the corresponding source file?

By including in that file the same header as everyone else, you will be warned at compile time should a change inadvertently "break" the contract.

Update (from @tmlen's comment): even if in this case it does not, an include file may also use declarations and pragmas such as #defines, typedef, enum, struct and inline as well as compiler macros, that would make no sense writing more than once (actually that would be dangerous to write in two different places, lest the copies get out of sync with each other with disastrous results). Some of those (eg a structure padding pragma ) could become bugs difficult to track down.

Answer 4

It is useful because functions can be declared before they are defined.

So it happens that you have the declaration, followed by a call\\invocation, followed by the implementation. You don't have to, but you can.

The header file contains the declarations. You're free to invoke anytime as long as the prototype matches. And as long as the compiler finds an implementation before finishing compilation.

Answer 5

Practical example - assume the following files in a project:

/* foo.h */
#ifndef FOO_H
#define FOO_H
double foo( int x );
#endif

/* foo.c */
int foo( int x )
{
  ...
}

/* main.c */
#include "foo.h"

int main( void )
{
  double x = foo( 1 );
  ...
}

Note that the declaration in foo.h does not match the definition in foo.c ; the return types are different. main.c calls the foo function assuming it returns a double , according to the declaration in foo.h .

foo.c and main.c are compiled separately from each other. Since main.c calls foo as declared in foo.h , it compiles successfully. Since foo.c does not include foo.h , the compiler is not aware of the type mismatch between the declaration and definition, so it compiles successfully as well.

When you link the two object files together, the machine code for the function call won't match up with what the machine code for function definition expects. The function call expects a double value to be returned, but the function definition returns an int . This is a problem, especially if the two types aren't the same size. Best case scenario is you get a garbage result.

By including foo.h in foo.c , the compiler can catch this mismatch before you run your program.

And, as is pointed out in an earlier answer, if foo.h defines any types or constants used by foo.c , then you definitely need to include it.