Applying dynamic and static Libraries in C programming
Let's start by defining library, a library is a collection of modules stored in object format (1's and 0's) this objects can be called from any other piece of code. In the C programming world these libraries are designed with the help of all the headers files (.h) and (.c) files that the headers call, so speaking of an example (all code can be downloaded here: Github ) let's say that we have our main.c program and that we want to use the add function from a previous calculator code:
#include "operators.h"
int main (void)
{
printf("Add result: %d\n", add(1, 5));
return (0);
}
We want to use a function to do the add action, but instead of putting the operators or creating a new function in our code we are gonna reuse one of our previous project's code and put the code into a library.
The first step is to create the object file from our c code for this task we can use the gcc compiler with the flag -c which is gonna avoid the linking stage in the compilation process (if you want to check more about compilation process click here: Gcc compilation process ) also, in this case, we are gonna apply dynamic linking for this we are gonna need that the address of our functions can be called relative, so we are gonna apply also the flag -fPIC.
After creating the .o file we are gonna need to create the dynamic library in linux they end with .so while in windows they end with .dll. the -shared flag is telling the compiler that we want a shared object and the -o flag, let's us put our own name, an important fact, the name of our library is all, lib and .so are naming convention that we have to obey.
Perfect, now to get our program running we have to compile our c code with our dynamic library.
At this point you could be wondering what's the use of having libraries in general, well let's suppose that we just don't wanna add numbers, but that we have a really complex mathematical algorithm that we tested a lot in previous projects and we know that it doesn't fail if we want to recycle that code we just create a library with all the important functions that we had and use them in our new project.
Also having a culture of creating libraries is really important because it is gonna give improve the style of creating modules that can be later updated, so our program can be running up to date and we won't have to touch all our code to create a new test.
- How do they work
Let's get a little deeper about Dynamic libraries, at the end of our compilation process in the linking stage, our main code is gonna be searching, for all the libraries that we need to execute successfully our code, in the case of dynamic linking we are just going to put the address our code needs to access the library in the future.
What about Static libraries? In this case, all our libraries are gonna be copied into our final executable making our executable size a little larger than when we have a Dynamic library, so how do we create and link a static library in c? as the same as with the Dynamic library, we need to create the .o file, the one we used to create for the Dynamic library is gonna be of use for a Static Library, having a relative path is not gonna be trouble when static linking.
Right now that's all we need to compile our program, but if we had a lot of libraries and we would want to compile them in just one we could use the command:
ar rcs static_lib.a *.o
r is used to insert the files into an archive, c create the archive if it doesn't exist without warnings, and s to write an index to each component of the file, but as we have only one file we are not gonna use ar.
So ... if we can get the same result, what's the difference? well one is still dependent on the library file while the other not we can check this deleting our .so and .o files
Finally, we know how to create Dynamic and Static Libraries, and have some differences that we would want to consider at the moment of using them in an important project:
Follow me on twitter: @DavidOrejuela14