CODEWITHSUNDEEP
ccompiler-constructionc-preprocessorstdiokernighan-and-ritchie
Thomas E
Thomas E

Reputation: 379

Standard libraries included multiple times over several files?

In the K&R book (p59) (edit: second edition, covering ANSI C), it is suggested that it is easier to split larger projects into multiple files. In each file, several libraries are included at the top as usual: e.g. getop.c needs stdio.h, and so does stack.c and so does main.c.

The snippets are something like this:

//main.c
#include <stdio.h>
#include <stdlib.h>
#include "calc.h"
int main(void)
{
    //etc
}


//getop.c
#include <stdio.h>
#include <ctype.h>
#include "calc.h"
getop()
{
    /*code*/
}

//stack.c
#include <stdio.h>
#include "calc.h"
void push(double val)
{
    //code
}

I am having trouble figuring out how including the standard libraries several times in a project works. Of course, for the custom .c files to be able to access built in functions, we need to include #include <header.h> so that they are aware of the existence of printf() and getchar() and so on, but wouldn't this approach increase the size of the final program if stdio.h is included four times instead of once ( if everything was placed in one file)?

K&R does point out that splitting a program over several files eventually makes it more difficult to maintain all the .h files.

I suppose what I am really asking is how does the compiler figure out the problem of one library being #included several times in a project.

I have read up on using include guards, but it seems that is not needed for this implementation, as they deal with ensuring that identical bits of code aren't included twice, as in:

File "module.h"

#ifndef MODULE_H
#define MODULE_H

struct foo {
    int member;
};

#endif /* MODULE_H */

File "mod2.h"

#include "module.h"

File "prog.c"

#include "module.h"
#include "mod2.h"

refs

Upvotes: 4

Views: 7340

Answers (2)

Iharob Al Asimi
Iharob Al Asimi

Reputation: 53036

Because they use something called include guards, suppose your own include files where to be included more than once, then you can do this

MyHeader.h

#ifndef MY_HEADER_H
#define MY_HEADER_H
/* file content goes here */
#endif /* MY_HEADER_H */

Then you have another header

**AnotherHeader.h**

#ifndef MY_ANOTHER_HEADER_H
#define MY_ANOTHER_HEADER_H
#include "MyHeader.h"
/* file content goes here */
#endif /* MY_ANOTHER_HEADER_H */

and in your program

main.c

/* 
 * MY_HEADER_H is undefined so it will be defined and MyHeader.h contents 
 * will be included.
 */
#include "MyHeader.h" 
/*
 * MY_HEADER_H is defined now, so MyHeader.h contents will not be included
 */
#include "AnotherHeader.h"

int main()
{
    return 0;
}

Since the included files are only included once per compilation unit the resulting binary size will not increase, besides the inclusion of header files only increases the compiled file size when for example there are string literals declared in those headers, otherwise they only provide information to the compiler about how to call a given function, i.e. how to pass parameters to it and how to store its returned value.

Upvotes: 2

wimh
wimh

Reputation: 15232

I suppose what I am really asking is how does the compiler figure out the problem of one library being #included several times in a project.

you don't include a library by #include <stdio.h>, you just include it's declarations, so the compiler knows what functions exists. The linker takes care of including a library and putting everything together.

Upvotes: 4

Related Questions