Understanding the Difference Between Static and Dynamic Libraries

Hello, I am Xiao Feng, and today we will briefly discuss the differences between static libraries and dynamic libraries.

Computer programs run in memory, which is divided into code, data, heap, and stack regions.

The program’s memory layout looks like this, with particular focus on the code section.

The code section contains the code you wrote as well as the libraries you use, including the standard library and any non‑standard (ordinary) libraries.

First, we look at the compilation stage. Suppose you write a reusable addition function in its own source file; the source is compiled into an object file, and the linker packages the object files into the final executable.

If many developers adopt your functions, they become a de‑facto standard, forming the standard library.

Often a library is only used by its author; such non‑standard libraries remain private.

Regardless of being standard or not, the next step is linking.

Static linking packs your code and all required libraries into the executable, producing a self‑contained binary.

When the program runs, the executable is loaded into memory, occupying the same code, data, heap, and stack regions described earlier.

If every program statically links the standard library, each executable contains a duplicate copy of that library, wasting disk and memory space.

Dynamic linking solves this problem. The standard library is compiled once as a shared (dynamic) library—*.so on Linux, *.dll on Windows.

The executable now contains only a reference to the shared library (its name and location). At runtime, the dynamic linker loads the shared library into memory, allowing multiple programs to share the same code.

Thus, dynamic linking reduces both disk usage and memory consumption, and updating a bug in a shared library only requires rebuilding the library, not the entire application.

In summary, static linking bundles all required code into the executable, making deployment simple but increasing size and complicating updates; dynamic linking keeps a single shared copy of libraries, saving space and allowing easier updates.