动态库链接流程、静态/动态库区分及路径链接疑问

Great questions about how linking works—let’s break this down in plain terms, since this is a common point of confusion for anyone diving into low-level program execution.

How do programs/linkers distinguish shared libraries from static libraries? #

It’s not just about the file suffix (.so vs .a), though those are widely followed conventions. The real distinction comes down to the file’s internal format and how the linker interacts with it:

• Static libraries (.a): These are archive files that bundle a collection of compiled object files (.o). When linking against a static library, the linker scans the archive, pulls out only the object files your program actually uses, and copies their code directly into your final executable. The result is a standalone binary with no external library dependencies at runtime.
• Shared libraries (.so): These are fully compiled shared objects with their own memory layout and relocation metadata. The linker never copies code from the .so into your executable—instead, it adds a reference to the library (either its name or full path) to your executable’s dynamic section. At runtime, the system’s dynamic loader (like ld-linux.so on Linux) loads the .so into memory and resolves the necessary symbol references.

You can easily verify a library’s type using the file command:

# Check a static library
file libfoo.a
# Output example: libfoo.a: current ar archive

# Check a shared library
file libfoo.so
# Output example: libfoo.so: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked

Linkers also let you explicitly control linking behavior with flags. For example, with GCC:

• -lfoo will prefer a shared library (libfoo.so) if it exists; if not, it’ll fall back to the static library (libfoo.a).
• Use -Wl,-Bstatic -lfoo -Wl,-Bdynamic to force static linking for libfoo while keeping other dependencies dynamic.
• -static will force static linking for all libraries (assuming static versions are available).

Does linking to a dynamic library via its full path convert it to static linking? #

No, this won’t happen at all. The linker decides whether to link statically or dynamically based on the file’s format, not the path you use to specify it.

If you run a command like:

gcc main.c /path/to/libfoo.so -o myprogram

The linker recognizes /path/to/libfoo.so as a shared object. It will:

1. Validate that the library is compatible with your executable (same architecture, etc.)
2. Add an entry for /path/to/libfoo.so (or sometimes just libfoo.so, depending on linker flags) to your executable’s dynamic dependency list.
3. Resolve any symbols your program uses from the library at link time—but it never copies the library’s code into your executable.

You can confirm this by running ldd myprogram—it will show /path/to/libfoo.so as a dynamic dependency. The library’s code is loaded at runtime when your program starts, not embedded into the binary.

To statically link, you must use the static archive (.a) version of the library, like:

gcc main.c /path/to/libfoo.a -o myprogram

Or use the -static flag if you want to link all dependencies statically.

内容的提问来源于stack exchange，提问作者shota silagadze