Using a Static Library in Your Program

In the previous lessons, you learned:

• Why libraries exist

• What static libraries are

• How they are built

• The tools used (gcc, ar, ranlib, nm)

Now we answer the final and most practical question:

How do you actually use a static library in your program?

This is where everything comes together.

1. The Goal

You have:

• A static library (.a file)

• A header file (.h)

• A program (main.c)

Your goal is:

To use functions from the library inside your program.

2. The Key Idea

When using a static library:

• Your program does not contain the function code directly

• It only knows how to call the functions

• The actual code is added during compilation

3. Step 1: Include the Header File

Your header file contains function prototypes.

Example:

#include "main.h"

Why is this important?

Because the compiler needs to know:

• function names

• return types

• parameters

Think of the header file as a contract.

It tells your program:

“These functions exist, and this is how to use them.”

4. Step 2: Write Your Program

Now you write your program normally.

Example idea:

int main(void)
{
    some_function();
    return 0;
}

You are calling a function that exists in your library.

But the function is not defined in this file.

5. Step 3: Link the Library During Compilation

This is the most important step.

When compiling your program, you must tell the compiler:

• where to find the library

• which library to use

Conceptually:

program + library → executable

During this step:

• the compiler searches the library

• finds the functions you used

• includes them in the final executable

6. What Actually Happens During Linking

When you compile:

1. The compiler reads your program

2. It sees a function call

3. It looks for that function in the library

4. It copies the function’s compiled code into your program

So the final executable contains everything it needs.

7. Important Insight

Your program only includes the functions it actually uses.

Even if your library has 50 functions:

• If you use 2, only those 2 are included

This keeps your program efficient.

8. File Structure Overview

A typical setup looks like this:

main.c
main.h
libmy.a

Or more structured:

src/
    functions.c

include/
    main.h

lib/
    libmy.a

main.c

The structure may vary, but the idea remains the same.

9. Why Header Files Matter

Without a header file:

• The compiler does not know your function exists

• You may get errors like:

  • “implicit declaration of function”

Header files ensure:

• consistency

• correctness

• easier debugging

10. Common Beginner Mistakes

❌ Forgetting to include the header file

This leads to compilation errors.

❌ Forgetting to link the library

Even if your code is correct, the program won’t compile properly.

❌ Mismatch between prototype and implementation

If your header file says:

int add(int a, int b);

But your function is different, errors will occur.

❌ Wrong library name

Remember:

libmy.a → -lmy

The compiler removes:

• lib

• .a

11. Putting Everything Together

Let’s summarize the full workflow:

1. Write functions (.c files)

2. Compile → object files (.o)

3. Bundle → static library (.a)

4. Include header in your program

5. Link library during compilation

6. Run your program

This is the complete process.

12. Practice Thinking (Before Coding)

Before you try this practically, think through these:

1. Why does your program need a header file if the library already contains the functions?

2. At what stage are the library functions added to your program?

3. Why doesn’t your program need the .a file after compilation?

4. What would happen if you forget to link the library?

Key Ideas to Remember

• A header file tells your program how to use functions

• The library contains the actual function implementations

• Linking connects your program to the library

• The final executable becomes self-contained

• Only used functions are included

What’s Next

You now understand:

• what static libraries are

• how they are built

• how they are used

The next step is applying all of this in your project.

You will:

• build your own static library

• organize your files properly

• follow strict rules

• test your implementation

This is where your understanding turns into real skill.