-1

I am new to C and am just learning the basics of modularising my code for neatness and maintainability. I am reading a lot of people saying not to include .c files directly but instead to use .h files with associated .c files.

My question is, when writing a library which is exposed/included via its .h file - does the compiler dedupe common includes or are the included each time they are referenced?

enter image description here

For instance in my above application, I am using printf in my main and also in my foo library.

When running:

gcc -o app main foo/foo.c && ./app

I get the expected outputs printed to the console, however does the compiler remove duplicates of the <stdio.h> include or is it included once for main.c and once again for foo.c?

David Alsh
  • 6,747
  • 6
  • 34
  • 60
  • 3
    Please do not post code as an image - [reasoning](https://meta.stackoverflow.com/questions/285551/why-not-upload-images-of-code-on-so-when-asking-a-question). Copy it as formatted text into the question. – kaylum Sep 23 '21 at 01:18
  • it really depends how you are compiling it. in this case you aren't creating a new library. – Daniel A. White Sep 23 '21 at 01:19
  • The C compiler doesn't automatically remove header duplicates. But there is a common pattern to ensure headers are only included once per translation unit. See the duplicate post for details. – kaylum Sep 23 '21 at 01:20
  • Include guards aren't the issue here - we're talking about the same header being included in two *different* translation units. – Nate Eldredge Sep 23 '21 at 02:39

2 Answers2

1

No, the compiler does not remove them. Nor should it, because sometimes (although it's rare) headers are written with the purpose of being included several times with different effects each time. So the compiler can't just omit these subsequent inclusions.

That's why people put include guards in headers (#ifndef FOO_H_ in this case.)

Each file, regardless of whether is a .h or .c file, should include what it needs. It should not rely that a header has already been included somewhere else. If something is included twice in the current compilation unit, the include guards will make sure headers are only included once, regardless of how many files try to include them.

As a side note, #pragma once, even though it's not in the C standard, is a de-facto standard compiler extension. So you can use just do:

#pragma once

void foo();

It's one of those rare cases where a non-standard compiler extension is so widely supported that it's safe to use.

Nikos C.
  • 50,738
  • 9
  • 71
  • 96
1

In contrary, each compilation unit ("main.c" and "foo.c" in your case) needs that include. Otherwise the compiler would not know the prototype of printf()(note). Each compilation unit (aka "module") is compiled on its own.

You might mix up headers and linkable files (object code files, and libraries).

The contents of a header file replaces the #include line during preprocessing. "stdio.h" contains only the prototype of printf(), among a lot of other stuff, not the implementation of the function.

If the compiler generates the object code for "main.c" and "foo.c", each of them includes an unresolved reference to printf().

Finally the linker will include the object code for printf(), but just once. This single instance of the function is called by both callers. Here happens what you seem to ask.

You might wonder why you don't have to add the library to your command line. This is a convenience feature of most compiler drivers, as nearly all applications want the standard libraries. You might like to add "-v" to the command line to see what really happens. Other options can suppress this automation.

Note: Some compilers are quite smart and know a lot of standard functions. They will accept the source and produce a nice warning. But don't rely on this.

the busybee
  • 10,755
  • 3
  • 13
  • 30