A static library is simply a group of object files. The object files are kept in an archive, which leads to their usual .a suffix extension. You can think of archives as similar to a zip file, but without compression.

Below we show the creation of basic static library and introduce some common tools for working with libraries.

  1 
                  $ cat library.c
    /* Library Function */
    int function(int input)
  5 {
            return input + 10;
    }
    
    $ cat library.h
 10 /* Function Definition */
    int function(int);
    
    $ cat program.c
    #include <stdio.h>
 15 /* Library header file */
    #include "library.h"
    
    int main(void)
    {
 20         int d = function(100);
    
            printf("%d\n", d);
    }
    
 25 $ gcc -c library.c
    $ ar rc libtest.a library.o
    $ ranlib ./libtest.a
    $ nm --print-armap ./libtest.a
    
 30 Archive index:
    function in library.o
    
    library.o:
    00000000 T function
 35 
    $ gcc -L . program.c -ltest -o program
    
    $ ./program
    110
 40 
                

Firstly we compile or library to an object file, just as we have seen in the previous chapter.

Notice that we define the library API in the header file. The API consists of function definitions for the functions in the library; this is so that the compiler knows what types the functions take when building object files that reference the library (e.g. program.c, which #includes the header file).

We create the library ar (short for "archive") command. By convention static library file names are prefixed with lib and have the extension .a. The c argument tells the program to create the archive, and a tells archive to add the object files specified into the library file.^[27]

Next we use the ranlib application to make a header in the library with the symbols of the object file contents. This helps the compiler to quickly reference symbols; in the case where we just have one this step may seem a little redundant; however a large library may have thousands of symbols meaning an index can significantly speed up finding references. We inspect this new header with the nm application. We see the function symbol for the function() function at offset zero, as we expect.

You then specify the library to the compiler with -lname where name is the filename of the library without the prefix lib. We also provide an extra search directory for libraries, namely the current directory (-L .), since by default the current directory is not searched for libraries.

The final result is a single executable with our new library included.

Static linking is very straight forward, but has a number of drawbacks.

There are two main disadvantages; firstly if the library code is updated (to fix a bug, say) you have to recompile your program into a new executable and secondly, every program in the system that uses that library contains a copy in it's executable. This is very inefficient (and a pain if you find a bug and have to recompile, as per point one).

For example, the C library (glibc) is included in all programs, and provides all the common functions such as printf.