kaksha.dev

---

Static Library vs. Dynamic Library

Static Library:

• A static library, also known as an archive, is a collection of precompiled object files packaged together.
• During the compilation phase, the compiler links the object files from the static library directly into the executable (program) being built.
• The code from the static library becomes part of the final executable, making it larger in size.
• Once the program is compiled, it doesn’t rely on the presence of the original static library during runtime. All the necessary code is already included in the executable.
• Since the library code is directly integrated into the executable, static libraries provide faster execution times at runtime.
• However, if multiple programs use the same static library, each program will have its own copy of the library code, leading to increased disk space usage.

Dynamic Library:

• A dynamic library, also known as a shared library or DLL (Dynamic Link Library) in Windows systems, is a separate file containing compiled code.
• During the compilation phase, the compiler only adds references (symbolic links) to the functions and code present in the dynamic library, not the actual code itself.
• The actual linking of the dynamic library to the program occurs during runtime when the program is loaded into memory.
• Dynamic libraries are loaded into memory once and shared among multiple programs that use them. This reduces disk space usage and allows for more efficient memory management.
• Since dynamic libraries are loaded during runtime, updates or bug fixes to the library can be applied without recompiling the entire program.
• Dynamic libraries may result in a slight overhead at runtime due to the need to locate and load the library into memory. However, this overhead is often negligible compared to the benefits of sharing the library among multiple programs.

---

Compilation Process

When compiling a C program, the compiler generates object code. What is an object file? In our case, it is a file that contains object code and typically has a .o extension. Then, the compiler also invokes the linker. One of the main tasks of the linker is to make the code of library functions (e.g., printf(), scanf(), sqrt(), etc.) available to your program. This task can be accomplished in two ways by the linker:

• By copying the code of library functions to your object code.
• By making some arrangements so that the complete code of library functions is not copied, but made available at runtime.

By convention, the static library has the prefix lib and the suffix .a. Example: lib_myLibrary.a.

Step-by-Step Example: Creating a Static Library in C

Step 1: Create the Header File

Create a new text file with a .h extension. For example, you could name it addition.h.

Define Function Prototypes

In the header file, define the function prototype for the add function. This allows other source files to know about the function and its parameters without seeing the implementation details.

addition.h:

// Function prototype for addition
int add(int a, int b);

Step 2: Save the Header File

Save the header file in the same directory where your source code files are located.

Step 3: Include the Header in Source Files

In any source file where you want to use the add function, include the header file using the #include directive.

main.c:

#include <stdio.h>
#include "addition.h" // Include the custom header

int main() {
    int result = add(10, 5);
    printf("Addition result: %d\n", result);
    return 0;
}

Step 4: Create the Implementation for the Header File

Write the implementation of the add function in a .c file.

addition.c:

int add(int a, int b) {
    return a + b;
}

---

Step 5: Compile the Library Implementation

Run the following command to compile the addition.c file into an object file.

gcc -c addition.c -o addition_output.o

Step 6: Create the Static Library

Use the ar command to bundle multiple object files into a static library:

ar rcs lib_myLibrary.a addition_output.o

• r: Replace existing files in the library.
• c: Create the library if it does not exist.
• s: Create a sorted index of the library for faster access.

Step 7: Create the Main Program

main.c:

#include <stdio.h>
#include "addition.h"

int main() {
    printf("Addition is %d", add(2, 3));
    return 0;
}

Step 8: Compile the Program with the Static Library

Compile the program using the following command:

gcc -o test_output main.c -L. lib_myLibrary.a

• -L. tells the linker to look in the current directory for libraries.
• lib_myLibrary.a is the static library that contains the implementation of the add function.

Explanation of the -L. Option

In C and C++ programming, the -L. option is used to specify a directory where the linker should look for libraries during the compilation process. Specifically, it adds the current directory (.) to the list of paths that the linker searches for libraries.

If you have a custom library named mylibrary located in the same directory as your source code, you might compile and link your program like this:

gcc -o my_program main.c -L. -lmylibrary

• -L. tells the linker to search the current directory for libraries.
• -lmylibrary tells the linker to look for libmylibrary.a or libmylibrary.so.

---