C Custom Libraries Tutorial

1. Creating a Custom Library

To create a custom library in C, you need to follow these steps:

• Create a header file (.h) containing function prototypes.
• Create a source file (.c) containing the function definitions.
• Compile the source file into an object file (.o).
• Use `ar` to create a static library (.a) from the object file.

/* mymath.h - Header file */
#ifndef MYMATH_H
#define MYMATH_H

int add(int a, int b);
int subtract(int a, int b);

#endif

/* mymath.c - Source file */
#include "mymath.h"

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

int subtract(int a, int b) {
    return a - b;
}
                

2. Compiling the Library

After defining your functions in the source file, compile them into an object file and then create the static library:

gcc -c mymath.c -o mymath.o
ar rcs libmymath.a mymath.o
                

This will generate a static library `libmymath.a` that you can link to your projects.

3. Using the Custom Library in Your Code

Once the custom library is created, you can include its header file in your main C program and link against the library during compilation:

/* main.c */
#include <stdio.h>
#include "mymath.h"

int main() {
    int sum = add(5, 3);
    int difference = subtract(5, 3);
    printf("Sum: %d, Difference: %d\n", sum, difference);
    return 0;
}
                

To compile and link the program with your custom library, use the following command:

gcc main.c -L. -lmymath -o main
                

The `-L.` option tells the compiler to look for libraries in the current directory, and `-lmymath` links the `libmymath.a` library.

4. Dynamic Libraries (Optional)

Alternatively, you can create dynamic (shared) libraries using the following steps:

gcc -shared -o libmymath.so mymath.c
                

Link to the dynamic library during compilation:

gcc main.c -L. -lmymath -o main
                

Dynamic libraries offer flexibility as they are linked at runtime rather than compile-time.

5. Conclusion

Creating custom libraries in C allows you to modularize your code, making it more maintainable and reusable. Whether you use static or dynamic libraries, this approach helps you manage large codebases efficiently.