3. Shared Libraries3. Shared Libraries 3. 共享库

3.1. Conventions3.1. Conventions 3.1. 约定

For shared libraries to support all of these desired properties, a number of conventions and guidelines must be followed. You need to understand the difference between a library's names, in particular its ``soname'' and ``real name'' (and how they interact). You also need to understand where they should be placed in the filesystem.For shared libraries to support all of these desired properties, a number of conventions and guidelines must be followed. You need to understand the difference between a library's names, in particular its ``soname'' and ``real name'' (and how they interact). You also need to understand where they should be placed in the filesystem.为了让共享库支持所有这些期望的特性，必须遵循一些约定和准则。你需要理解库的名称之间的区别，特别是它的“soname”（共享目标文件名）和“real name”（真实名称）（以及它们如何相互作用）。你还需要了解它们应该放在文件系统的哪个位置。

3.2. How Libraries are Used3.2. How Libraries are Used 3.2. 库的使用方式

On GNU glibc-based systems, including all Linux systems, starting up an ELF binary executable automatically causes the program loader to be loaded and run. On Linux systems, this loader is named /lib/ld-linux.so.X (where X is a version number). This loader, in turn, finds and loads all other shared libraries used by the program.On GNU glibc-based systems, including all Linux systems, starting up an ELF binary executable automatically causes the program loader to be loaded and run. On Linux systems, this loader is named /lib/ld-linux.so.X (where X is a version number). This loader, in turn, finds and loads all other shared libraries used by the program.在基于GNU glibc的系统（包括所有Linux系统）上，启动ELF二进制可执行文件会自动导致程序加载器被加载并运行。在Linux系统上，这个加载器名为/lib/ld-linux.so.X（其中X是版本号）。而这个加载器会进而查找并加载该程序所使用的所有其他共享库。

The list of directories to be searched is stored in the file /etc/ld.so.conf. Many Red Hat-derived distributions don't normally include /usr/local/lib in the file /etc/ld.so.conf. I consider this a bug, and adding /usr/local/lib to /etc/ld.so.conf is a common ``fix'' required to run many programs on Red Hat-derived systems.The list of directories to be searched is stored in the file /etc/ld.so.conf. Many Red Hat-derived distributions don't normally include /usr/local/lib in the file /etc/ld.so.conf. I consider this a bug, and adding /usr/local/lib to /etc/ld.so.conf is a common ``fix'' required to run many programs on Red Hat-derived systems.要搜索的目录列表存储在文件/etc/ld.so.conf中。许多源自Red Hat的发行版通常不会在文件/etc/ld.so.conf中包含/usr/local/lib。我认为这是一个漏洞，而将/usr/local/lib添加到/etc/ld.so.conf是在源自Red Hat的系统上运行许多程序时所需的一种常见“修复”方法。

If you want to just override a few functions in a library, but keep the rest of the library, you can enter the names of overriding libraries (.o files) in /etc/ld.so.preload; these ``preloading'' libraries will take precedence over the standard set. This preloading file is typically used for emergency patches; a distribution usually won't include such a file when delivered.If you want to just override a few functions in a library, but keep the rest of the library, you can enter the names of overriding libraries (.o files) in /etc/ld.so.preload; these ``preloading'' libraries will take precedence over the standard set. This preloading file is typically used for emergency patches; a distribution usually won't include such a file when delivered.如果你只想覆盖库中的几个函数，而保留库的其余部分，可以在/etc/ld.so.preload中输入覆盖库（.o文件）的名称；这些“预加载”库将优先于标准库集。这个预加载文件通常用于紧急补丁；发行版在交付时通常不会包含这样的文件。

Searching all of these directories at program start-up would be grossly inefficient, so a caching arrangement is actually used. The program ldconfig(8) by default reads in the file /etc/ld.so.conf, sets up the appropriate symbolic links in the dynamic link directories (so they'll follow the standard conventions), and then writes a cache to /etc/ld.so.cache that's then used by other programs. This greatly speeds up access to libraries. The implication is that ldconfig must be run whenever a DLL is added, when a DLL is removed, or when the set of DLL directories changes; running ldconfig is often one of the steps performed by package managers when installing a library. On start-up, then, the dynamic loader actually uses the file /etc/ld.so.cache and then loads the libraries it needs. Searching all of these directories at program start-up would be grossly inefficient, so a caching arrangement is actually used. The program ldconfig(8) by default reads in the file /etc/ld.so.conf, sets up the appropriate symbolic links in the dynamic link directories (so they'll follow the standard conventions), and then writes a cache to /etc/ld.so.cache that's then used by other programs. This greatly speeds up access to libraries. The implication is that ldconfig must be run whenever a DLL is added, when a DLL is removed, or when the set of DLL directories changes; running ldconfig is often one of the steps performed by package managers when installing a library. On start-up, then, the dynamic loader actually uses the file /etc/ld.so.cache and then loads the libraries it needs. 在程序启动时搜索所有这些目录会非常低效，因此实际使用了缓存机制。程序ldconfig(8)默认会读取文件/etc/ld.so.conf，在动态链接目录中设置适当的符号链接（使其遵循标准约定），然后将缓存写入/etc/ld.so.cache，供其他程序使用。这大大加快了对库的访问速度。这意味着，每当添加、删除动态链接库（DLL），或者动态链接库目录集发生变化时，都必须运行ldconfig；包管理器在安装库时，通常会执行运行ldconfig这一步骤。因此，动态加载器在启动时实际上会使用/etc/ld.so.cache文件，然后加载所需的库。

By the way, FreeBSD uses slightly different filenames for this cache. In FreeBSD, the ELF cache is /var/run/ld-elf.so.hints and the a.out cache is /var/run/ld.so.hints. These are still updated by ldconfig(8), so this difference in location should only matter in a few exotic situations.By the way, FreeBSD uses slightly different filenames for this cache. In FreeBSD, the ELF cache is /var/run/ld-elf.so.hints and the a.out cache is /var/run/ld.so.hints. These are still updated by ldconfig(8), so this difference in location should only matter in a few exotic situations.顺便说一下，FreeBSD对这个缓存使用的文件名略有不同。在FreeBSD中，ELF缓存是/var/run/ld-elf.so.hints，a.out缓存是/var/run/ld.so.hints。这些仍然由ldconfig(8)更新，所以位置上的这种差异只在少数特殊情况下有影响。

3.3. Environment Variables3.3. Environment Variables 3.3. 环境变量

Various environment variables can control this process, and there are environment variables that permit you to override this process.Various environment variables can control this process, and there are environment variables that permit you to override this process.多种环境变量可以控制这一过程，也有一些环境变量允许你覆盖此过程。

3.4. Creating a Shared Library3.4. Creating a Shared Library 3.4. 创建共享库

Creating a shared library is easy. First, create the object files that will go into the shared library using the gcc -fPIC or -fpic flag. The -fPIC and -fpic options enable ``position independent code'' generation, a requirement for shared libraries; see below for the differences. You pass the soname using the -Wl gcc option. The -Wl option passes options along to the linker (in this case the -soname linker option) - the commas after -Wl are not a typo, and you must not include unescaped whitespace in the option. Then create the shared library using this format:Creating a shared library is easy. First, create the object files that will go into the shared library using the gcc -fPIC or -fpic flag. The -fPIC and -fpic options enable ``position independent code'' generation, a requirement for shared libraries; see below for the differences. You pass the soname using the -Wl gcc option. The -Wl option passes options along to the linker (in this case the -soname linker option) - the commas after -Wl are not a typo, and you must not include unescaped whitespace in the option. Then create the shared library using this format:创建共享库很简单。首先，使用gcc的-fPIC或-fpic标志创建将放入共享库的目标文件。-fPIC和-fpic选项启用“位置无关代码”生成，这是共享库的要求；下面会介绍两者的区别。使用-Wl gcc选项传递soname。-Wl选项将选项传递给链接器（在这种情况下是-soname链接器选项）——-Wl后面的逗号不是拼写错误，并且在该选项中不能包含未转义的空格。然后使用以下格式创建共享库：

gcc -shared -Wl,-soname,your_soname \
    -o library_name file_list library_listgcc -shared -Wl,-soname,your_soname \
    -o library_name file_list library_listgcc -shared -Wl,-soname,your_soname \-o library_name file_list library_list

Here's an example, which creates two object files (a.o and b.o) and then creates a shared library that contains both of them. Note that this compilation includes debugging information (-g) and will generate warnings (-Wall), which aren't required for shared libraries but are recommended. The compilation generates object files (using -c), and includes the required -fPIC option:Here's an example, which creates two object files (a.o and b.o) and then creates a shared library that contains both of them. Note that this compilation includes debugging information (-g) and will generate warnings (-Wall), which aren't required for shared libraries but are recommended. The compilation generates object files (using -c), and includes the required -fPIC option:以下是一个示例，它会创建两个目标文件（a.o 和 b.o），然后创建一个包含这两个文件的共享库。请注意，此次编译包含调试信息（-g）并会生成警告（-Wall），这些对于共享库来说并非必需，但建议添加。编译会生成目标文件（使用 -c），并包含必需的 -fPIC 选项：

gcc -fPIC -g -c -Wall a.c
gcc -fPIC -g -c -Wall b.c
gcc -shared -Wl,-soname,libmystuff.so.1 \
    -o libmystuff.so.1.0.1 a.o b.o -lcgcc -fPIC -g -c -Wall a.c
gcc -fPIC -g -c -Wall b.c
gcc -shared -Wl,-soname,libmystuff.so.1 \
    -o libmystuff.so.1.0.1 a.o b.o -lcgcc -fPIC -g -c -Wall a.cgcc -fPIC -g -c -Wall b.cgcc -shared -Wl,-soname,libmystuff.so.1 \-o libmystuff.so.1.0.1 a.o b.o -lc

Here are a few points worth noting: Here are a few points worth noting: 以下是几点值得注意的内容：

• Don't strip the resulting library, and don't use the compiler option -fomit-frame-pointer unless you really have to. The resulting library will work, but these actions make debuggers mostly useless.Don't strip the resulting library, and don't use the compiler option -fomit-frame-pointer unless you really have to. The resulting library will work, but these actions make debuggers mostly useless.不要对生成的库进行剥离操作，除非确实必要，否则不要使用编译器选项-fomit-frame-pointer。生成的库仍然可以运行，但这些操作会使调试器基本失效。

• Use -fPIC or -fpic to generate code. Whether to use -fPIC or -fpic to generate code is target-dependent. The -fPIC choice always works, but may produce larger code than -fpic (mnenomic to remember this is that PIC is in a larger case, so it may produce larger amounts of code). Using -fpic option usually generates smaller and faster code, but will have platform-dependent limitations, such as the number of globally visible symbols or the size of the code. The linker will tell you whether it fits when you create the shared library. When in doubt, I choose -fPIC, because it always works.Use -fPIC or -fpic to generate code. Whether to use -fPIC or -fpic to generate code is target-dependent. The -fPIC choice always works, but may produce larger code than -fpic (mnenomic to remember this is that PIC is in a larger case, so it may produce larger amounts of code). Using -fpic option usually generates smaller and faster code, but will have platform-dependent limitations, such as the number of globally visible symbols or the size of the code. The linker will tell you whether it fits when you create the shared library. When in doubt, I choose -fPIC, because it always works.使用-fPIC或-fpic来生成代码。是否使用-fPIC或-fpic生成代码取决于目标平台。选择-fPIC总是可行的，但生成的代码可能比使用-fpic时更大（记住这一点的助记法是，PIC是大写的，所以它可能生成更多的代码）。使用-fpic选项通常会生成更小、更快的代码，但会有平台相关的限制，例如全局可见符号的数量或代码的大小。在创建共享库时，链接器会告诉你它是否适用。如果有疑问，我会选择-fPIC，因为它总是有效的。

• In some cases, the call to gcc to create the object file will also need to include the option ``-Wl,-export-dynamic''. Normally, the dynamic symbol table contains only symbols which are used by a dynamic object. This option (when creating an ELF file) adds all symbols to the dynamic symbol table (see ld(1) for more information). You need to use this option when there are 'reverse dependencies', i.e., a DL library has unresolved symbols that by convention must be defined in the programs that intend to load these libraries. For ``reverse dependencies'' to work, the master program must make its symbols dynamically available. Note that you could say ``-rdynamic'' instead of ``-Wl,export-dynamic'' if you only work with Linux systems, but according to the ELF documentation the ``-rdynamic'' flag doesn't always work for gcc on non-Linux systems.In some cases, the call to gcc to create the object file will also need to include the option ``-Wl,-export-dynamic''. Normally, the dynamic symbol table contains only symbols which are used by a dynamic object. This option (when creating an ELF file) adds all symbols to the dynamic symbol table (see ld(1) for more information). You need to use this option when there are 'reverse dependencies', i.e., a DL library has unresolved symbols that by convention must be defined in the programs that intend to load these libraries. For ``reverse dependencies'' to work, the master program must make its symbols dynamically available. Note that you could say ``-rdynamic'' instead of ``-Wl,export-dynamic'' if you only work with Linux systems, but according to the ELF documentation the ``-rdynamic'' flag doesn't always work for gcc on non-Linux systems.在某些情况下，调用gcc创建目标文件时还需要包含选项``-Wl,-export-dynamic''。通常，动态符号表只包含动态对象所使用的符号。此选项（在创建ELF文件时）会将所有符号添加到动态符号表中（更多信息请参见ld(1)）。当存在“反向依赖”时，即DL库存在未解析的符号，按照惯例，这些符号必须在打算加载这些库的程序中定义，这时就需要使用该选项。为了使“反向依赖”生效，主程序必须使其符号可动态获取。请注意，如果仅在Linux系统上运行，可以使用``-rdynamic''代替``-Wl,export-dynamic''，但根据ELF文档，``-rdynamic''标志在非Linux系统上并不总是能在gcc中正常工作。

During development, there's the potential problem of modifying a library that's also used by many other programs -- and you don't want the other programs to use the ``developmental''library, only a particular application that you're testing against it. One link option you might use is ld's ``rpath'' option, which specifies the runtime library search path of that particular program being compiled. From gcc, you can invoke the rpath option by specifying it this way: During development, there's the potential problem of modifying a library that's also used by many other programs -- and you don't want the other programs to use the ``developmental''library, only a particular application that you're testing against it. One link option you might use is ld's ``rpath'' option, which specifies the runtime library search path of that particular program being compiled. From gcc, you can invoke the rpath option by specifying it this way: 在开发过程中，可能会出现这样一个问题：修改一个同时被许多其他程序使用的库——而你不希望其他程序使用这个“开发版”库，只希望你正在针对它进行测试的某个特定应用程序使用该库。你可以使用的一个链接选项是ld的“rpath”选项，它指定了正在编译的那个特定程序的运行时库搜索路径。在gcc中，你可以通过以下方式指定来调用rpath选项：

-Wl,-rpath,$(DEFAULT_LIB_INSTALL_PATH) -Wl,-rpath,$(DEFAULT_LIB_INSTALL_PATH)-Wl,-rpath,$(DEFAULT_LIB_INSTALL_PATH)

If you use this option when building the library client program, you don't need to bother with LD_LIBRARY_PATH (described next) other than to ensure it's not conflicting, or using other techniques to hide the library. If you use this option when building the library client program, you don't need to bother with LD_LIBRARY_PATH (described next) other than to ensure it's not conflicting, or using other techniques to hide the library.如果在构建库客户端程序时使用此选项，您无需费心处理LD_LIBRARY_PATH（下文将介绍），只需确保它不会产生冲突，或者使用其他技术来隐藏该库即可。

3.5. Installing and Using a Shared Library3.5. Installing and Using a Shared Library3.5. 安装和使用共享库

Once you've created a shared library, you'll want to install it. The simple approach is simply to copy the library into one of the standard directories (e.g., /usr/lib) and run ldconfig(8).Once you've created a shared library, you'll want to install it. The simple approach is simply to copy the library into one of the standard directories (e.g., /usr/lib) and run ldconfig(8).创建共享库后，你会想要安装它。简单的方法是直接将库复制到某个标准目录（例如 /usr/lib）并运行 ldconfig(8)。

First, you'll need to create the shared libraries somewhere. Then, you'll need to set up the necessary symbolic links, in particular a link from a soname to the real name (as well as from a versionless soname, that is, a soname that ends in ``.so'' for users who don't specify a version at all). The simplest approach is to run: First, you'll need to create the shared libraries somewhere. Then, you'll need to set up the necessary symbolic links, in particular a link from a soname to the real name (as well as from a versionless soname, that is, a soname that ends in ``.so'' for users who don't specify a version at all). The simplest approach is to run: 首先，你需要在某个位置创建共享库。然后，你需要设置必要的符号链接，特别是从共享库版本名（soname）到实际名称的链接（以及从无版本共享库版本名的链接，即对于完全不指定版本的用户来说，是一个以“.so”结尾的共享库版本名）。最简单的方法是运行：

ldconfig -n directory_with_shared_libraries ldconfig -n directory_with_shared_librariesldconfig -n 包含共享库的目录

Finally, when you compile your programs, you'll need to tell the linker about any static and shared libraries that you're using. Use the -l and -L options for this.Finally, when you compile your programs, you'll need to tell the linker about any static and shared libraries that you're using. Use the -l and -L options for this.最后，当你编译程序时，需要告知链接器你正在使用的所有静态库和共享库。为此，请使用-l和-L选项。

If you can't or don't want to install a library in a standard place (e.g., you don't have the right to modify /usr/lib), then you'll need to change your approach. In that case, you'll need to install it somewhere, and then give your program enough information so the program can find the library... and there are several ways to do that. You can use gcc's -L flag in simple cases. You can use the ``rpath'' approach (described above), particularly if you only have a specific program to use the library being placed in a ``non-standard'' place. You can also use environment variables to control things. In particular, you can set LD_LIBRARY_PATH, which is a colon-separated list of directories in which to search for shared libraries before the usual places. If you're using bash, you could invoke my_program this way using:If you can't or don't want to install a library in a standard place (e.g., you don't have the right to modify /usr/lib), then you'll need to change your approach. In that case, you'll need to install it somewhere, and then give your program enough information so the program can find the library... and there are several ways to do that. You can use gcc's -L flag in simple cases. You can use the ``rpath'' approach (described above), particularly if you only have a specific program to use the library being placed in a ``non-standard'' place. You can also use environment variables to control things. In particular, you can set LD_LIBRARY_PATH, which is a colon-separated list of directories in which to search for shared libraries before the usual places. If you're using bash, you could invoke my_program this way using:如果你无法或不想将库安装在标准位置（例如，你没有权限修改/usr/lib），那么你需要改变方法。在这种情况下，你需要将其安装到某个地方，然后向你的程序提供足够的信息，以便程序能够找到该库……有几种方法可以做到这一点。在简单情况下，你可以使用gcc的-L标志。你可以使用“rpath”方法（如上所述），特别是当你只有一个特定程序需要使用放在“非标准”位置的库时。你也可以使用环境变量来控制相关设置。特别是，你可以设置LD_LIBRARY_PATH，它是一个以冒号分隔的目录列表，程序会在常规位置之前先在这些目录中搜索共享库。如果你使用bash，你可以通过以下方式调用my_program：

LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH  my_programLD_LIBRARY_PATH=.:$LD_LIBRARY_PATH  my_programLD_LIBRARY_PATH=.:$LD_LIBRARY_PATH  my_program

If you want to override just a few selected functions, you can do this by creating an overriding object file and setting LD_PRELOAD; the functions in this object file will override just those functions (leaving others as they were).If you want to override just a few selected functions, you can do this by creating an overriding object file and setting LD_PRELOAD; the functions in this object file will override just those functions (leaving others as they were).如果你只想覆盖几个选定的函数，可以通过创建一个覆盖对象文件并设置LD_PRELOAD来实现；该对象文件中的函数将仅覆盖那些函数（其他函数保持原样）。

Usually you can update libraries without concern; if there was an API change, the library creator is supposed to change the soname. That way, multiple libraries can be on a single system, and the right one is selected for each program. However, if a program breaks on an update to a library that kept the same soname, you can force it to use the older library version by copying the old library back somewhere, renaming the program (say to the old name plus ``.orig''), and then create a small ``wrapper'' script that resets the library to use and calls the real (renamed) program. You could place the old library in its own special area, if you like, though the numbering conventions do permit multiple versions to live in the same directory. The wrapper script could look something like this: Usually you can update libraries without concern; if there was an API change, the library creator is supposed to change the soname. That way, multiple libraries can be on a single system, and the right one is selected for each program. However, if a program breaks on an update to a library that kept the same soname, you can force it to use the older library version by copying the old library back somewhere, renaming the program (say to the old name plus ``.orig''), and then create a small ``wrapper'' script that resets the library to use and calls the real (renamed) program. You could place the old library in its own special area, if you like, though the numbering conventions do permit multiple versions to live in the same directory. The wrapper script could look something like this: 通常情况下，你可以放心更新库；如果存在API变更，库的创建者应该会更改版本名。这样一来，单个系统上就可以存在多个库，并且每个程序都会选择到正确的库。不过，如果某个程序在更新保持相同版本名的库后出现问题，你可以通过以下方式强制它使用旧版本的库：将旧库复制回某个位置，重命名该程序（比如在旧名称后加上``.orig''），然后创建一个小型的“包装器”脚本，该脚本会重置要使用的库并调用真正（已重命名）的程序。你可以根据喜好将旧库放在专门的位置，尽管编号约定允许多个版本共存于同一目录中。包装器脚本可能如下所示：

#!/bin/sh export LD_LIBRARY_PATH=/usr/local/my_lib:$LD_LIBRARY_PATH exec /usr/bin/my_program.orig $* #!/bin/sh export LD_LIBRARY_PATH=/usr/local/my_lib:$LD_LIBRARY_PATH exec /usr/bin/my_program.orig $*#!/bin/sh export LD_LIBRARY_PATH=/usr/local/my_lib:$LD_LIBRARY_PATH exec /usr/bin/my_program.orig $*

Please don't depend on this when you write your own programs; try to make sure that your libraries are either backwards-compatible or that you've incremented the version number in the soname every time you make an incompatible change. This is just an ``emergency'' approach to deal with worst-case problems. Please don't depend on this when you write your own programs; try to make sure that your libraries are either backwards-compatible or that you've incremented the version number in the soname every time you make an incompatible change. This is just an ``emergency'' approach to deal with worst-case problems.在编写自己的程序时，请不要依赖这一点；要确保你的库要么具有向后兼容性，要么在每次进行不兼容的更改时，都已在soname中增加了版本号。这只是一种用于处理最坏情况问题的“应急”方法。

You can see the list of the shared libraries used by a program using ldd(1). So, for example, you can see the shared libraries used by ls by typing: You can see the list of the shared libraries used by a program using ldd(1). So, for example, you can see the shared libraries used by ls by typing: 你可以使用ldd(1)查看程序所使用的共享库列表。例如，你可以通过输入以下命令查看ls所使用的共享库：

ldd /bin/ls ldd /bin/ls LDD /bin/ls

Generally you'll see a list of the sonames being depended on, along with the directory that those names resolve to. In practically all cases you'll have at least two dependencies: Generally you'll see a list of the sonames being depended on, along with the directory that those names resolve to. In practically all cases you'll have at least two dependencies: 通常你会看到一个所依赖的共享对象名称列表，以及这些名称所解析到的目录。实际上，在几乎所有情况下，你至少会有两个依赖项：

• /lib/ld-linux.so.N (where N is 1 or more, usually at least 2). This is the library that loads all other libraries./lib/ld-linux.so.N (where N is 1 or more, usually at least 2). This is the library that loads all other libraries./lib/ld-linux.so.N（其中N为1或更大，通常至少为2）。这是加载所有其他库的库。

• libc.so.N (where N is 6 or more). This is the C library. Even other languages tend to use the C library (at least to implement their own libraries), so most programs at least include this one.libc.so.N (where N is 6 or more). This is the C library. Even other languages tend to use the C library (at least to implement their own libraries), so most programs at least include this one.libc.so.N（其中N为6或更大的数字）。这是C库。即使是其他语言也倾向于使用C库（至少会用它来实现自己的库），因此大多数程序至少会包含这个库。

3.6. Incompatible Libraries3.6. Incompatible Libraries 3.6. 不兼容的库

When a new version of a library is binary-incompatible with the old one the soname needs to change. In C, there are four basic reasons that a library would cease to be binary compatible: When a new version of a library is binary-incompatible with the old one the soname needs to change. In C, there are four basic reasons that a library would cease to be binary compatible: 当一个库的新版本与旧版本存在二进制不兼容时，其版本标识（soname）需要更改。在C语言中，库失去二进制兼容性有四个基本原因：

1. The behavior of a function changes so that it no longer meets its original specification,The behavior of a function changes so that it no longer meets its original specification,函数的行为发生了变化，不再符合其原始规范，

2. Exported data items change (exception: adding optional items to the ends of structures is okay, as long as those structures are only allocated within the library).Exported data items change (exception: adding optional items to the ends of structures is okay, as long as those structures are only allocated within the library).导出的数据项会发生变化（例外情况：只要结构仅在库内分配，向结构末尾添加可选项是允许的）。

3. An exported function is removed.An exported function is removed. 一个导出函数被移除。

4. The interface of an exported function changes.The interface of an exported function changes.导出函数的接口发生了变化。

If you can avoid these reasons, you can keep your libraries binary-compatible. Said another way, you can keep your Application Binary Interface (ABI) compatible if you avoid such changes. For example, you might want to add new functions but not delete the old ones. You can add items to structures but only if you can make sure that old programs won't be sensitive to such changes by adding items only to the end of the structure, only allowing the library (and not the application) to allocate the structure, making the extra items optional (or having the library fill them in), and so on. Watch out - you probably can't expand structures if users are using them in arrays.If you can avoid these reasons, you can keep your libraries binary-compatible. Said another way, you can keep your Application Binary Interface (ABI) compatible if you avoid such changes. For example, you might want to add new functions but not delete the old ones. You can add items to structures but only if you can make sure that old programs won't be sensitive to such changes by adding items only to the end of the structure, only allowing the library (and not the application) to allocate the structure, making the extra items optional (or having the library fill them in), and so on. Watch out - you probably can't expand structures if users are using them in arrays.如果能避免这些原因，你就能保持库的二进制兼容性。换句话说，如果你避免此类更改，就能保持应用程序二进制接口（ABI）的兼容性。例如，你可能想要添加新函数，但不删除旧函数。你可以向结构体中添加项目，但前提是你能确保旧程序不会对这类更改敏感，方法包括仅在结构体末尾添加项目、只允许库（而非应用程序）分配结构体、让额外项目成为可选项（或让库来填充它们）等等。要注意——如果用户在数组中使用结构体，你很可能无法扩展结构体。

For C++ (and other languages supporting compiled-in templates and/or compiled dispatched methods), the situation is trickier. All of the above issues apply, plus many more issues. The reason is that some information is implemented ``under the covers'' in the compiled code, resulting in dependencies that may not be obvious if you don't know how C++ is typically implemented. Strictly speaking, they aren't ``new'' issues, it's just that compiled C++ code invokes them in ways that may be surprising to you. The following is a (probably incomplete) list of things that you cannot do in C++ and retain binary compatibility, as reported by Troll Tech's Technical FAQ: For C++ (and other languages supporting compiled-in templates and/or compiled dispatched methods), the situation is trickier. All of the above issues apply, plus many more issues. The reason is that some information is implemented ``under the covers'' in the compiled code, resulting in dependencies that may not be obvious if you don't know how C++ is typically implemented. Strictly speaking, they aren't ``new'' issues, it's just that compiled C++ code invokes them in ways that may be surprising to you. The following is a (probably incomplete) list of things that you cannot do in C++ and retain binary compatibility, as reported by Troll Tech's Technical FAQ: 对于C++（以及其他支持编译时模板和/或编译时分派方法的语言），情况更为复杂。上述所有问题都存在，而且还有更多问题。原因是有些信息是在编译后的代码中“秘密地”实现的，这导致如果你不了解C++的典型实现方式，可能会看不出其中的依赖关系。严格来说，这些并不是“新”问题，只是编译后的C++代码以可能会让你感到惊讶的方式引发了这些问题。以下是（可能并不完整的）在C++中无法做到却仍能保持二进制兼容性的事项列表，来源于Troll Tech的技术常见问题解答：

1. add reimplementations of virtual functions (unless it it safe for older binaries to call the original implementation), because the compiler evaluates SuperClass::virtualFunction() calls at compile-time (not link-time).add reimplementations of virtual functions (unless it it safe for older binaries to call the original implementation), because the compiler evaluates SuperClass::virtualFunction() calls at compile-time (not link-time).添加虚函数的重新实现（除非旧二进制文件调用原始实现是安全的），因为编译器在编译时（而非链接时）对SuperClass::virtualFunction()调用进行求值。

2. add or remove virtual member functions, because this would change the size and layout of the vtbl of every subclass. add or remove virtual member functions, because this would change the size and layout of the vtbl of every subclass. 添加或删除虚成员函数，因为这会改变每个子类的虚函数表的大小和布局。

3. change the type of any data members or move any data members that can be accessed via inline member functions.change the type of any data members or move any data members that can be accessed via inline member functions.更改任何数据成员的类型，或者移动任何可通过内联成员函数访问的数据成员。

4. change the class hierarchy, except to add new leaves. change the class hierarchy, except to add new leaves. 更改类层次结构，但添加新的叶节点除外。

5. add or remove private data members, because this would change the size and layout of every subclass. add or remove private data members, because this would change the size and layout of every subclass. 添加或删除私有数据成员，因为这会改变每个子类的大小和布局。

6. remove public or protected member functions unless they are inline.remove public or protected member functions unless they are inline.除非成员函数是内联的，否则移除公共或受保护的成员函数。

7. make a public or protected member function inline.make a public or protected member function inline.将公共或受保护的成员函数设为内联函数。

8. change what an inline function does, unless the old version continues working.change what an inline function does, unless the old version continues working.改变内联函数的功能，除非旧版本仍能正常工作。

9. change the access rights (i.e. public, protected or private) of a member function in a portable program, because some compilers mangle the access rights into the function name.change the access rights (i.e. public, protected or private) of a member function in a portable program, because some compilers mangle the access rights into the function name.在可移植程序中更改成员函数的访问权限（即公共、受保护或私有），因为有些编译器会将访问权限混入函数名中。

Given this lengthy list, developers of C++ libraries in particular must plan for more than occasional updates that break binary compatibility. Fortunately, on Unix-like systems (including Linux) you can have multiple versions of a library loaded at the same time, so while there is some disk space loss, users can still run ``old'' programs needing old libraries.Given this lengthy list, developers of C++ libraries in particular must plan for more than occasional updates that break binary compatibility. Fortunately, on Unix-like systems (including Linux) you can have multiple versions of a library loaded at the same time, so while there is some disk space loss, users can still run ``old'' programs needing old libraries.鉴于这份冗长的清单，C++库的开发者尤其必须做好准备，应对那些打破二进制兼容性的频繁更新。幸运的是，在类Unix系统（包括Linux）上，你可以同时加载一个库的多个版本，因此，尽管会占用一些磁盘空间，用户仍然可以运行需要旧库的“旧”程序。