# 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:

```c
#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:

```c
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:

```text
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:

```text
main.c
main.h
libmy.a
```

Or more structured:

```text
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:

```c
int add(int a, int b);
```

But your function is different, errors will occur.

### ❌ Wrong library name

Remember:

```text
libmy.a → -lmy
```

The compiler removes:

*   `lib`
    
*   `.a`
    

## 11\. Putting Everything Together

Let’s summarize the full workflow:

```text
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.