Beginner's question on misc functions and header files

Just a simple question if you please:

Lets say that over the years in programming in C you wrote a lot of helper functions and macros to for instance allocate memory or do a safer strcmp or define constants, etc.

Do you guys normally keep all these functions in one library and one header file that you include in all your programs or do you rather keep a gazillion smaller libraries and header files that have very specific functions in it to be able to include only what is needed?


Thanks!

You can always have many specific header files, and then have a convenience header that includes the other header files.

At least with GCC, if you compile each independent function into it's own object file, GCC will make sure that only what is actually used will end up in the resulting binary. For example, suppose you define these custom functions

int myfunc1(int myparam);
int myfunc2(int myparam);
int myfunc3(int myparam);

Then, you can compile each function definition with gcc's "-c" flag to produce three separate object files, for example

myfunc1.o
myfunc2.o
myfunc3.o

Now, let's say you make a program called myprogram.c, which makes use of 0 or more of these functions. Compiling myprogram with the command

gcc -o myprogram myprogram.c myfunc1.o myfunc2.o myfunc3.o

will automatically leave out the .o files which are not actually used by myprogram. The list of object files may get long, so normally you combine them all into an "archive file" named libfoo.a and then link it using the -lfoo flag:

gcc -o myprogram myprogram.c -lmyfunctions

GCC makes the assumption in this case that you have an archive file named "libmyfunctions.a" somewhere in your library search path, and the result should be the same as in listing the .o files. If you're not using GCC, a similar system is used by other compilers, but the details vary from compiler to compiler.

A correction to the last post:

GCC will perform the optimization described (removing instances of uncalled functions myfunc1, myfunc2 and myfunc3) only if compiled with the following procedure or its equivalent:

gcc -fdata-sections -ffunction-sections -c myfunc1.o -Wl,--gc-sections
gcc -fdata-sections -ffunction-sections -c myfunc2.o -Wl,--gc-sections
gcc -fdata-sections -ffunction-sections -c myfunc3.o -Wl,--gc-sections
# (Now combine all of your .o files into an archive file such as libmyfunctions.a)
gcc -fdata-sections -ffunction-sections -o myprogram myprogram.c -lmyfunctions -Wl,--gc-sections

This will allow the linker to discover whether myfunc1, myfunc2 and myfunc3 are unused in myprogram and leave them off of the resulting binary, myprogram.

Unfortunately, this doesn't work in the standard MinGW linker. However, there is a patch available which solves it, here: Bug 11539 – ld --gc-sections should work for PE-COFF on MinGW

Comments on that page report savings of several megabytes on programs which are linking against large static libraries such as Qt, so this patch could be interesting if the static library you are linking against gets large.

EDIT (Clarifying the commands):

The linker options are only needed for the last step, and the -f options are not needed in the last step. Simplified example commands:

gcc -fdata-sections -ffunction-sections -c myfunc1.o
gcc -fdata-sections -ffunction-sections -c myfunc2.o
gcc -fdata-sections -ffunction-sections -c myfunc3.o
ar r libmyfunctions.a myfunc1.o myfunc2.o myfunc3.o
gcc -L. -o myprogram myprogram.c -lmyfunctions -Wl,--gc-sections

The option -L. says to look for libmyfunctions.a in the current directory. This is not needed if you put libmyfunctions.a into a directory which is specified in your LIBRARY_PATH.

Also, using an archive file with each object file containing a single function seems the best way for GCC. In this mode, MinGW with the standard linker will not link the unneeded object files if you didn't actually use them in your program.

If the function definitions are small and depend on only a few auxiliary functions, I keep them in a C file with a bunch of other related functions, then just copy and paste the functions I need into the projects I'm working on. If it's an entire library of functions that are used together, then I keep one or more C files along with a header file and copy them into the project's directory. If it's a large library consisting of many C and C header files I'll usually maintain that as a separate project and build a shared, dynamically linked library.