执行静态链接构建的一个原因是验证可执行文件是否完全关闭，即所有符号引用都正确解析。

作为使用持续集成构建和测试的大型系统的一部分，夜间回归测试使用可执行文件的静态链接版本运行。偶尔，我们会看到一个符号无法解析，静态链接会失败，即使动态链接的可执行文件可以成功链接。

这种情况通常发生在共享库中位置较深的符号有拼写错误的名称，因此不能进行静态链接时。无论使用深度优先还是宽度优先求值，动态链接器都不能完全解析所有符号，因此您可以完成一个没有完全闭包的动态链接可执行文件。

1/我曾经参与过一个项目，其中动态链接和静态链接是基准测试，差异并没有小到可以切换到动态链接(我没有参与测试，我只知道结论)

2/ Dynamic linking is often associated with PIC (Position Independent Code, code which doesn't need to be modified depending on the address at which it is loaded). Depending on the architecture PIC may bring another slowdown but is needed in order to get benefit of sharing a dynamically linked library between two executable (and even two process of the same executable if the OS use randomization of load address as a security measure). I'm not sure that all OS allow to separate the two concepts, but Solaris and Linux do and ISTR that HP-UX does as well.

3/我在其他项目中使用了动态链接的“简单补丁”功能。但是这个“简单补丁”使得小补丁的发布更加容易，而复杂补丁的发布则成为版本控制的噩梦。因为错误的版本是token，我们经常不得不推送所有内容，并在客户站点跟踪问题。

我的结论是，我使用静态链接除外:

比如依赖于动态链接的插件 当共享是重要的(大型库被多个进程同时使用，如C/ c++运行时，GUI库，…它们通常是独立管理的，ABI对此有严格的定义)

如果有人想使用“简单的补丁”，我认为库必须像上面的大库一样管理:它们必须几乎独立，具有定义好的ABI，不能被修复更改。

Dynamic linking can reduce total resource consumption (if more than one process shares the same library (including the version in "the same", of course)). I believe this is the argument that drives its presence in most environments. Here "resources" include disk space, RAM, and cache space. Of course, if your dynamic linker is insufficiently flexible there is a risk of DLL hell. Dynamic linking means that bug fixes and upgrades to libraries propagate to improve your product without requiring you to ship anything. Plugins always call for dynamic linking. Static linking, means that you can know the code will run in very limited environments (early in the boot process, or in rescue mode). Static linking can make binaries easier to distribute to diverse user environments (at the cost of sending a larger and more resource-hungry program). Static linking may allow slightly faster startup times, but this depends to some degree on both the size and complexity of your program and on the details of the OS's loading strategy.

Some edits to include the very relevant suggestions in the comments and in other answers. I'd like to note that the way you break on this depends a lot on what environment you plan to run in. Minimal embedded systems may not have enough resources to support dynamic linking. Slightly larger small systems may well support dynamic linking because their memory is small enough to make the RAM savings from dynamic linking very attractive. Full-blown consumer PCs have, as Mark notes, enormous resources, and you can probably let the convenience issues drive your thinking on this matter.

要解决性能和效率问题:视情况而定。

通常情况下，动态库需要某种粘合层，这通常意味着双重分派或函数寻址中额外的间接层，并且可能会消耗一点速度(但是函数调用时间实际上是运行时间的很大一部分吗??)

但是，如果您正在运行多个进程，并且它们都经常调用同一个库，那么使用动态链接而不是静态链接时，您最终可以节省缓存行(从而赢得运行性能)。(除非现代操作系统足够智能，能够在静态链接的二进制文件中注意到相同的段。似乎很难，有人知道吗?)

另一个问题:加载时间。你需要支付装货费用。你什么时候支付这个费用取决于操作系统的工作方式以及你使用的链接。也许你宁愿推迟支付，直到你知道你需要它。

注意，静态链接与动态链接传统上不是一个优化问题，因为它们都涉及到对目标文件的单独编译。然而，这并不是必需的:原则上，编译器可以最初将“静态库”“编译”到一个摘要的AST表单中，并通过将这些AST添加到为主代码生成的AST中来“链接”它们，从而实现全局优化。我使用的系统都没有做到这一点，所以我不能评论它的工作效果如何。

回答性能问题的方法总是通过测试(并尽可能使用与部署环境相似的测试环境)。

我同意dnmckee提到的观点，另外:

静态链接的应用程序可能更容易部署，因为很少或没有额外的文件依赖项(.dll / .so)，当它们丢失或安装在错误的位置时，可能会导致问题。

Another consideration is the number of object files (translation units) that you actually consume in a library vs the total number available. If a library is built from many object files, but you only use symbols from a few of them, this might be an argument for favoring static linking, since you only link the objects that you use when you static link (typically) and don't normally carry the unused symbols. If you go with a shared lib, that lib contains all translation units and could be much larger than what you want or need.

在大量且越来越多的系统中，极端的静态链接可以对应用程序和系统性能产生巨大的积极影响。

我指的是通常所说的“嵌入式系统”，其中许多现在越来越多地使用通用操作系统，这些系统被用于所有可以想象到的事情。

An extremely common example are devices using GNU/Linux systems using Busybox. I've taken this to the extreme with NetBSD by building a bootable i386 (32-bit) system image that includes both a kernel and its root filesystem, the latter which contains a single static-linked (by crunchgen) binary with hard-links to all programs that itself contains all (well at last count 274) of the standard full-feature system programs (most except the toolchain), and it is less than 20 megabytes in size (and probably runs very comfortably in a system with only 64MB of memory (even with the root filesystem uncompressed and entirely in RAM), though I've been unable to find one so small to test it on).

It has been mentioned in earlier posts that the start-up time of a static-linked binaries is faster (and it can be a lot faster), but that is only part of the picture, especially when all object code is linked into the same file, and even more especially when the operating system supports demand paging of code direct from the executable file. In this ideal scenario the startup time of programs is literally negligible since almost all pages of code will already be in memory and be in use by the shell (and and init any other background processes that might be running), even if the requested program has not ever been run since boot since perhaps only one page of memory need be loaded to fulfill the runtime requirements of the program.

However that's still not the whole story. I also usually build and use the NetBSD operating system installs for my full development systems by static-linking all binaries. Even though this takes a tremendous amount more disk space (~6.6GB total for x86_64 with everything, including toolchain and X11 static-linked) (especially if one keeps full debug symbol tables available for all programs another ~2.5GB), the result still runs faster overall, and for some tasks even uses less memory than a typical dynamic-linked system that purports to share library code pages. Disk is cheap (even fast disk), and memory to cache frequently used disk files is also relatively cheap, but CPU cycles really are not, and paying the ld.so startup cost for every process that starts every time it starts will take hours and hours of CPU cycles away from tasks which require starting many processes, especially when the same programs are used over and over, such as compilers on a development system. Static-linked toolchain programs can reduce whole-OS multi-architecture build times for my systems by hours. I have yet to build the toolchain into my single crunchgen'ed binary, but I suspect when I do there will be more hours of build time saved because of the win for the CPU cache.