A dynamic-link library (DLL) is an executable file that acts as a shared library of functions. Dynamic
linking provides a way for a process to call a function that is not part of its executable code. The
executable code for the function is located in a DLL, which contains one or more functions that are
compiled, linked, and stored separately from the processes that use them. DLLs also facilitate the
sharing of data and resources. Multiple applications can simultaneously access the contents of a single
copy of a DLL in memory.

Dynamic linking differs from static linking in that it allows an executable module (either a .dll or .exe
file) to include only the information needed at run time to locate the executable code for a DLL
function. In static linking, the linker gets all of the referenced functions from the static link library and
places it with your code into your executable.

Using dynamic linking instead of static linking offers several advantages. DLLs save memory, reduce
swapping, save disk space, upgrade easier, provide after-market support, provide a mechanism to
extend the MFC library classes, support multilanguage programs, and ease the creation of international
versions.

Even though DLLs and applications are both executable program modules, they differ in several ways.
To the end-user, the most obvious difference is that DLLs are not programs that can be directly
executed. From the system's point of view, there are two fundamental differences between applications
and DLLs:

them do not need to be recompiled or relinked as long as the functions' arguments and return values do not change. In contrast, statically linked object code requires that the application be relinked when the functions change.