Static vs Dynamic Libraries - C Programming

Creating libraries for your programs can be a useful tool to make your job as a web developer more efficient.

If you don't know already, a library in programming is a collection of prewritten code that you can use to optimize tasks. This code is usually targeted for specific common problems such as building apps and website more efficiently. It can help with user authentication, server connection, user interfaces, algorithms, data management and so much more!

Now you might be asking yourself: "but how do I create one?" Before we answer that question, we must know that there is two different types of libraries: Static and dynamic.

A static library allows us to link to the program and are not relevant during the runtime, this makes it reusable in multiple programs but it is locked into one at compile time. On the other hand, dynamic libraries are preferably used when you want to run a lot of programs at the same time that are using the same library, and you want to be more efficient with it since these are separate files outside of the executable file.

Here's how to create a static library:

• "First thing you must do is create your C source files containing any functions that will be used. Your library can contain multiple object files.
• After creating the C source files, compile the files into object files.
• To create a library:

  ar rcs libmylib.a objfile1.o objfile2.o objfile3.o        

• This will create a static library called libname.a. Rename the "mylib" portion of the library to whatever you want.
• That is all that is required. If you plan on copying the library, remember to use the?-p?option with cp to preserve permissions."

How to use a static library:

• Remember to prototype your library function calls so that you do not get implicit declaration errors.
• When linking your program to the libraries, make sure you specify where the library can be found:

  gcc -o foo foo.o -L. -lmylib        

• The?-L.?piece tells gcc to look in the current directory in addition to the other library directories for finding libmylib.a.

Here's how to create a dynamic library:

• "Creating shared or dynamic libraries is simple also. Using the previous example, to create a shared library:

  gcc -fPIC -c objfile1.c
  gcc -fPIC -c objfile2.c
  gcc -fPIC -c objfile3.c
  gcc -shared -o libmylib.so objfile1.o objfile2.o objfile3.o        

• The -fPIC option is to tell the compiler to create Position Independent Code (create libraries using relative addresses rather than absolute addresses because these libraries can be loaded multiple times). The -shared option is to specify that an architecture-dependent shared library is being created. However, not all platforms support this flag.
• Now we have to compile the actual program using the libraries:

  gcc -o foo foo.o -L. -lmylib        

• Notice it is exactly the same as creating a static library. Although, it is compiled in the same way, none of the actual library code is inserted into the executable, hence the dynamic/shared library."

How to use a dynamic library:

• Since programs that use static libraries already have the library code compiled into the program, it can run on its own. Shared libraries dynamically access libraries?at run-time?thus the program needs to know where the shared library is stored. What's the advantage of creating executables using Dynamic Libraries? The executable is much smaller than with static libraries. If it is a standard library that can be installed, there is no need to compile it into the executable at compile time!
• The key to making your program work with dynamic libraries is through the?LD_LIBRARY_PATH?enviornment variable. To display this variable, at a shell:

  echo $LD_LIBRARY_PATH        

Will display this variable if it is already defined. If it isn't, you can create a wrapper script for your program to set this variable at run-time. Depending on your shell, simply use?setenv?(tcsh, csh) or?export?(bash, sh, etc) commands. If you already have LD_LIBRARY_PATH defined, make sure you?append?to the variable. For example:

  setenv LD_LIBRARY_PATH /path/to/library:${LD_LIBRARY_PATH}        

would be the command you would use if you had tcsh/csh and already had an existing LD_LIBRARY_PATH. An example with bash shells:

  export LD_LIBRARY_PATH=/path/to/library:${LD_LIBRARY_PATH}        

• If you have administrative rights to your computer, you can install the particular library to the /usr/local/lib directory if it makes sense and permanently add an LD_LIBRARY_PATH into your .tcshrc, .cshrc, .bashrc, etc. file.

Note: The LD_LIBRARY_PATH environment variable?tells the shell on Solaris systems which directories to search for client or shared IBM? Informix? general libraries. You must specify the directory that contains your client libraries before you can use the product. So in short, it specifies the search path for the library.

Useful related commands:

• nm: displays information about symbols in the specified library file.
• gcc (-L, -l): performs the compilation step to build a program, and then it calls other programs to assemble the program and to link the program's component parts into an executable program that you can run.
• ldd: lists the path names of all shared objects that would be loaded when filename is loaded.
• ldconfig: checks the header and filenames of the libraries it encounters when determining which versions should have their links updated.
• ar: combines one or more named files into a single archive file written in ar archive format.
• ranlib: converts each archive library to a random library.

Happy coding!