I have a number of
.c files, i.e. the implementation files say
Where functions from any of the files can call any function from a different files. My question being, do I need a
.h i.e. header file for each of A and B's implementation where each header file has the definition of ALL the functions in A or B.
Also, main.c will have both
B.h #included in it?
If someone can finally make it clear, also, how do I later compile and run the multiple files in the terminal.
A.c should only contain the information that is necessary for external code that uses the facilities defined in
A.c. It should not declare static functions; it should not declare static variables; it should not declare internal types (types used only in
A.c). It should ensure that a file can use just
#include "A.h" and then make full use of the facilities published by
A.c. It should be self-contained and idempotent (so you can include it twice without any compilation errors). You can simply check that the header is self-contained by writing
#include "A.h" as the first
#include line in
A.c; you can check that it is idempotent by including it twice (but that's better done as a separate test). If it doesn't compile, it is not self-contained. Similarly for
For more information on headers and standards, see 'Should I use
#include in headers?', which references a NASA coding standard, and 'Linking against a static library', which includes a script
chkhdr that I use for testing self-containment and idempotency.
main.o depends on
main.c itself does not depend on the headers.
When it comes to compilation, you can use:
gcc -o program main.c A.c B.c
If you need other options, add them (most flags at the start; libraries at the end, after the source code). You can also compile each file to object code separately and then link the object files together:
gcc -c main.c gcc -c A.c gcc -c B.c gcc -o program main.o A.o B.o