implicit header includes in C

Question

program.c :

int main () {

    hello();
    return 0;
}

tools.c :

void hello (void) {

    printf("hello world\n");
}

Makefile :

program : program.o tools.o

In the set of files of this program I have no tools.h file, even though it compiles fine with no errors, could someone explain the purpose of header files in C programs ?

For now I only have one idea : variables such as structures are required at the compilation layer...

But in my case, if the header file only contains function prototypes, is it longer required to build it ? (the makefile linker syntax is a bit easier to catch).

You think it compiles fine. Wait until you try to call `sqrt` without including `math.h`. — David Heffernan, Apr 02 '12 at 14:34
does it run successfully? Also do you get an `implicit definition of function` warning? — twain249, Apr 02 '12 at 14:35
@twain249 I get a warning but only for not including the header of stdio in tools.c, anyways the execution is fine — vdegenne, Apr 02 '12 at 14:39
It will work, but is not good style. As soon as you start adding arguments or requiring a return type you will need to forward declare your function, and as soon as you need to do that the header file becomes important as it saves you typing the same declaration in lots of times, just put it in a header file and #include it wherever you need it — Tom Quarendon, Apr 02 '12 at 14:48
Possible duplicate of [In C++ why have header files and cpp files?](http://stackoverflow.com/questions/333889/in-c-why-have-header-files-and-cpp-files). The C++ answer applies 100% to C as well. — Lundin, Apr 02 '12 at 15:52

score 1 · Answer 1 · answered Apr 02 '12 at 14:44

Header files usually would contain declarations of the functions which are defined in source c files.

What purpose does it serve?

It gives you additional safety, the compiler checks the parameters passed to a function against the declaration and reports errors if it finds an discrepancy.
They allow seperation of interface from the implementation.Basically, this allows you to provide your code(implementation) as an library, which clients need to link against while just including the interface header file in their applications.

Tom Quarendon · Answer 2 · 2012-04-02T15:01:48.407

1

In C, you are allowed to call a function that has not been declared, it is assumed to be an extern function that returns an int, and the compiler will allow you to pass any number of arguments of any type. Note that this is not recommended.

Header files are necessary to inform the C compiler of the correct signature, particularly the return type. If a declaration exists the compiler will check that the arguments passed match the declaration, although in very old style C only the number of arguments is checked, not their types. Since you can't overload functions in C, I believe that it is valid (though not recommended, and it may not actually work at runtime depending on the calling convention being used) to declare a function :

int hello();

And then actually implement it as :

int hello(char* who) {
    printf("Hello %s\n", who);
}

The linker will link these things together. Note that this is not good style.

Note that this is one of the key changes in C++, you must declare functions before calling them, and will check the types of all arguments.

edited Apr 02 '12 at 15:01

answered Apr 02 '12 at 14:46

Tom Quarendon

5,625
5
23
30

1

hmm, using a C++ compiler will garble all your function names, though, unless you're careful to wrap their forward declaration in `extern "C" { ... }` braces. This won't be a problem until someone tries to link with your library, while using a standard C compiler! – tehwalrus Apr 02 '12 at 14:55
That's true, you would need to put suitably guarded extern "C" in the headers, so it is not something that required no code change. I suppose my point was that you can write C with a C++ compiler, using the C++ compiler as a better C compiler. You don't need to write in C++ to benefit from a C++ compiler – Tom Quarendon Apr 02 '12 at 15:01
I agree, it's a good way to get some extra useful info out of your compiler - I just meant that it isn't without gotchas. – tehwalrus Apr 02 '12 at 15:10

score 0 · Answer 3 · answered Apr 02 '12 at 14:39

0

They allow you to share the declaration of functions, variables, structures.. between different c files.

answered Apr 02 '12 at 14:39

Flynch

84
3

score 0 · Answer 4 · answered Apr 02 '12 at 14:47

0

In your example, you are compiling both together. So it's fine and you are not getting any error despite missing forward declaraion for "hello".

But there are a many advantages for using header files such as: linking symbols from multiple files easily, avoiding forward declarations in every source file etc.

This greatly avoids multiple declarations all over the place in your source files and mostly importantly reduces the compile time just telling the compiler that the definition is somewhere there in the code.

answered Apr 02 '12 at 14:47

P.P

117,907
20
175
238

*avoiding forward declarations in every source file* is not an advantage, Infact, One should forward declare as much as and whenever possible. – Alok Save Apr 02 '12 at 14:49
@Als Not necessarily.That job is done by headers. Then why include headers at the top? Because they have declarations of the functions used that source. – P.P Apr 02 '12 at 15:22
Forward declarations are not only for functions but majorly for *types* and forward declaring types instead of including the headers which define them is a good practice.It saves you recompilation time, Build time, possibly helps you generate small sized binaries & doesn't pollute the global scope with unrequired gibberish. Do you see the light of advantages over the myth of disadvantages? – Alok Save Apr 02 '12 at 15:26
@Als Of course, there are advantages of FDs. But certainly header files avoid some of them when there's no need to declare it in every source file. In fact, all you said above in support of FD is the main reason to have a well-designed header file. In cases, where you have definitions in header files, this may add compile time overhead. But I would think, that's more to do with poor design than the problem with headers. To make it clear, I am not saying FDs are useless. Just headers do better job and avoids then when possible. – P.P Apr 02 '12 at 15:31

score 0 · Answer 5 · answered Apr 02 '12 at 14:50

Without a prototype for hello() in scope at the time of call, the compiler assumes (with a warning when properly configured) the prototype is int hello() (note, not int hello(void)).

But the definition does not agree with that prototype: void hello(void) vs int hello() so you've just unleashed Undefined Behaviour. Anything can happen. Specifically, your program may compile and run as you expect it to.

You can avoid that UB by providing a correct prototype, either by writing and including a header file, or by specifying the prototype directly in your program.c source file.

brice · Answer 6 · 2012-04-03T12:12:02.520

From the GCC docs:

Header files serve two purposes.

System header files declare the interfaces to parts of the operating system. You include them in your program to supply the definitions and declarations you need to invoke system calls and libraries.

Your own header files contain declarations for interfaces between the source files of your program. Each time you have a group of related declarations and macro definitions all or most of which are needed in several different source files, it is a good idea to create a header file for them.

Including a header file produces the same results as copying the header file into each source file that needs it. Such copying would be time-consuming and error-prone. With a header file, the related declarations appear in only one place. If they need to be changed, they can be changed in one place, and programs that include the header file will automatically use the new version when next recompiled. The header file eliminates the labor of finding and changing all the copies as well as the risk that a failure to find one copy will result in inconsistencies within a program.

My take is that C headers are legacy artefacts from the early days of C.

It's important to understand that headers are included verbatim into source files by the C preprocessor. So the question really becomes: Why do we need forward declaration?

In order to keep executables small, type information is not embedded in the object code generated by C compilers. Because of this, linking against an object file or library requires a definition of the types that each function provides, as this information is not available from the object file. Modern compilers get around this by inspecting the source code or libraries for definitions - Identifiers and signatures are grabbed directly from the source or the library symbols.
To keep compilers simple and efficient, it would have been inappropriate to type check definitions from the library they will be linked against. Indeed, it is perfectly valid to compile a file without the used library even being available on the compilation machine. Similarly, it would be onerous to delay the compilation of a type until its dependencies have been compiled, and downright impossible in case of cyclic relationships. This requires that the function signature be made available before the function is used (for type checking). For convenience, C defaults to int fun(...) so that in the then-commonest case, the need to forward-declare functions is lessened.

To make everybody's life easier, manual forward declarations were delegated to the pre-processor. In effect, the C compiler does not have the concept of a header file. Instead, the declarations are organised logically into header files which are then added to the program pre-compilation by the preprocessor.

This saves the programmer from having to type all the needed declarations at the beginning of every compilation unit, but it is essentially what is happening.

All this contortion is really a result of the limitations that existed in the early days of C.

There are, however, some definite advantages that result in these contortions. Having the function definitions available outside the implementation code itself allows clear separation between interface and implementation, which actually allows much cleaner systems to be built. In an ideal world, you would only ever need the header file to use a library, with no prior knowledge of the implementation. (aside: I'll trade you an ideal world for an invisible pink unicorn, if you ever find one.)

Modern languages have higher level constructs to separate implementation form interface: interfaces in Java, duck typing in Python, Protocols in Clojure, contracts in Eiffel, etc...

implicit header includes in C

6 Answers6