Is it safe to say we'd use static libraries when a program relies on functionality that rarely changes, such as C++ and STL (standard template library?) despite more space used since static library is linked at build time so becomes part of the final exe?
static libraries are most useful in programs that need to run on more computers, with fewer dependencies. the STL is almost entirely header files, so to call it static linking is technically accurate, but it doesn't tell the whole story. the C++ standard library - the parts that aren't template based - are usually linked dynamically, because it's possible, and likely, that many programs will use the shared functionality.
Pretty much what Elkvis said. Generally using a dynamically linked library is a good plan for code that is heavily shared between many programs. For example, C++ libraries, runtime support libraries, etc.. Or your own code, if it's going to be used by lots of different programs.Originally Posted by monkey_c_monkey
I've not thought of it having a 'how often functionality changes' factor. It's true that you can drop in updated dynamic libraries without having to relink your program, but I can't quite think of when that'd be useful. You can't change any interfaces or take advantage of new functions without relinking. But if you had all the interfaces in place you could develop a dynamic library independently I suppose.
I tend to favour static libraries. These days it's hard to get too freaked out about disk space.
automatic updates and bugfixes can easily be accomplished using this method. also, if your program supports a plugin interface, and the plugins are implemented as shared libraries with a common interface, this is extremely useful.
Dynamic libraries can be the source of many bugs (and bloat) since many versions tend to assume a given version of the library and will fail to work with a newer one. This makes one unable to update the library without breaking older applications.
The solution is usually to deprecate old functions and introduce new ones that new applications can use and leave the old ones for older applications. This causes bloat.
