/* math_ops.c — source for our static library */
#include "math_ops.h"

int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }
int subtract(int a, int b) { return a - b; }

/* math_ops.h */
int add(int a, int b);
int multiply(int a, int b);
int subtract(int a, int b);

# Step 1: Compile to object file (NO -fPIC needed for static libs)
gcc -c -Wall math_ops.c -o math_ops.o

# Step 2: Create the static library archive (.a file)
ar rcs libmath_ops.a math_ops.o
# ar options: r=insert, c=create, s=add index (for faster linking)

# Check what's inside the archive
ar t libmath_ops.a
# Output: math_ops.o

# Step 3: Link the application against the static library
gcc -o myapp main.c -L. -lmath_ops
# or explicitly: gcc -o myapp main.c ./libmath_ops.a

# Verify: no runtime dependency on libmath_ops
ldd myapp
# libmath_ops does NOT appear — its code is inside myapp itself

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

int main(void) {
    printf("3 + 4 = %d\n", add(3, 4));
    printf("3 * 4 = %d\n", multiply(3, 4));
    printf("7 - 2 = %d\n", subtract(7, 2));
    return 0;
}

If both libdemo.so and libdemo.a exist in the same directory and you link with -ldemo, the linker automatically prefers the shared version. You have to explicitly request static.

# Both exist: libdemo.so AND libdemo.a
ls ./libs/
# libdemo.a  libdemo.so

# Default: shared library is used
gcc -o prog main.c -L./libs -ldemo
ldd prog
# libdemo.so => ./libs/libdemo.so   <-- shared is chosen

# Check file size difference
ls -lh prog   # smaller (shared)

Method 1: Give the explicit .a file path

# Specify the .a file directly — no ambiguity
gcc -o prog main.c ./libs/libdemo.a

# Can also use absolute path
gcc -o prog main.c /usr/local/lib/libdemo.a

Method 2: -static flag (link EVERYTHING statically)

# Link everything statically, including libc
gcc -o prog main.c -static -L./libs -ldemo

# The resulting binary is completely self-contained
# but VERY large (includes libc, libm, etc.)
ldd prog
#   not a dynamic executable   <-- fully static!

# Check size — much larger
ls -lh prog
# Typical: 800KB+ vs 8KB for dynamic version

Method 3: -Wl,-Bstatic and -Wl,-Bdynamic (selective static linking)

# Link only libdemo statically, but other libraries dynamically
# The linker processes these flags left-to-right

gcc -o prog main.c \
    -Wl,-Bstatic -L./libs -ldemo \
    -Wl,-Bdynamic -lm -lpthread

# Effect:
#   libdemo → static (copied into binary)
#   libm, libpthread → dynamic (loaded at run time from .so)

# This is the most flexible approach:
# use static for YOUR library, dynamic for system libraries

# Practical example: embed OpenSSL statically, use system libc dynamically
gcc -o secure_app main.c \
    -Wl,-Bstatic \
    -L/opt/openssl-static/lib -lssl -lcrypto \
    -Wl,-Bdynamic \
    -lc

# Result: OpenSSL code is baked in, libc is still dynamic
ldd secure_app
# Shows: libc.so => ...   (dynamic)
# Does NOT show libssl or libcrypto (static)

With static libraries, link order matters. The linker scans archives left-to-right and only includes object files that satisfy unresolved symbols at that point. Circular dependencies between static libraries require listing a library multiple times.

# libA needs a symbol from libB, and libB needs a symbol from libA
# Solution: list libA twice (or use --start-group / --end-group)

gcc -o prog main.c -lA -lB -lA   # list libA again at the end

# Or use the group option (scans the group repeatedly until resolved):
gcc -o prog main.c -Wl,--start-group -lA -lB -Wl,--end-group