指定相互依赖的链接库的顺序是错误的。

如果库相互依赖，则库的链接顺序也很重要。通常，如果库A依赖于库B，那么在链接器标志中，libA必须出现在libB之前。

例如：

// B.h
#ifndef B_H
#define B_H

struct B {
    B(int);
    int x;
};

#endif

// B.cpp
#include "B.h"
B::B(int xx) : x(xx) {}

// A.h
#include "B.h"

struct A {
    A(int x);
    B b;
};

// A.cpp
#include "A.h"

A::A(int x) : b(x) {}

// main.cpp
#include "A.h"

int main() {
    A a(5);
    return 0;
};

创建库：

$ g++ -c A.cpp
$ g++ -c B.cpp
$ ar rvs libA.a A.o 
ar: creating libA.a
a - A.o
$ ar rvs libB.a B.o 
ar: creating libB.a
a - B.o

编译：

$ g++ main.cpp -L. -lB -lA
./libA.a(A.o): In function `A::A(int)':
A.cpp:(.text+0x1c): undefined reference to `B::B(int)'
collect2: error: ld returned 1 exit status
$ g++ main.cpp -L. -lA -lB
$ ./a.out

再说一遍，顺序很重要！

在链接共享库时，请确保未隐藏使用的符号。

gcc的默认行为是所有符号都可见。但是，当使用选项-fvisibility=hidden构建转换单元时，只有标记为__attribute__（（可见性（“默认”））的函数/符号在生成的共享对象中是外部的。

您可以通过调用以下命令来检查要查找的符号是否为外部符号：

# -D shows (global) dynamic symbols that can be used from the outside of XXX.so
nm -D XXX.so | grep MY_SYMBOL 

隐藏/本地符号用小写符号类型的nm表示，例如t而不是代码段的“t”：

nm XXX.so
00000000000005a7 t HIDDEN_SYMBOL
00000000000005f8 T VISIBLE_SYMBOL

您还可以使用nm和选项-C来定义名称（如果使用了C++）。

与Windows DLL类似，可以使用define标记公共函数，例如DLL_public定义为：

#define DLL_PUBLIC __attribute__ ((visibility ("default")))

DLL_PUBLIC int my_public_function(){
  ...
}

大致对应于Windows的/MSVC版本：

#ifdef BUILDING_DLL
    #define DLL_PUBLIC __declspec(dllexport) 
#else
    #define DLL_PUBLIC __declspec(dllimport) 
#endif

有关可见性的更多信息可以在gcc wiki上找到。

---

当使用-fvisibility=hidden编译翻译单元时，生成的符号仍然具有外部链接（以大写符号类型显示，单位为nm），如果对象文件成为静态库的一部分，则可以毫无问题地用于外部链接。只有当对象文件链接到共享库中时，链接才会变为本地链接。

要查找对象文件中隐藏的符号，请运行：

>>> objdump -t XXXX.o | grep hidden
0000000000000000 g     F .text  000000000000000b .hidden HIDDEN_SYMBOL1
000000000000000b g     F .text  000000000000000b .hidden HIDDEN_SYMBOL2

链接在引用库的对象文件之前使用库

您正在尝试编译程序并将其与GCC工具链链接。链接指定了所有必要的库和库搜索路径如果libfoo依赖于libbar，那么链接会正确地将libfoo放在libbar之前。链接失败，对某些错误的引用未定义。但是所有未定义的东西都在你的头文件中声明#并且实际上是在您链接的库中定义的。

示例在C中。它们也可以是C++

一个涉及您自己构建的静态库的最小示例

my_lib.c文件

#include "my_lib.h"
#include <stdio.h>

void hw(void)
{
    puts("Hello World");
}

my_lib.h

#ifndef MY_LIB_H
#define MT_LIB_H

extern void hw(void);

#endif

例如1.c

#include <my_lib.h>

int main()
{
    hw();
    return 0;
}

构建静态库：

$ gcc -c -o my_lib.o my_lib.c
$ ar rcs libmy_lib.a my_lib.o

编译程序：

$ gcc -I. -c -o eg1.o eg1.c

尝试将其与libmy_lib.a链接，但失败：

$ gcc -o eg1 -L. -lmy_lib eg1.o 
eg1.o: In function `main':
eg1.c:(.text+0x5): undefined reference to `hw'
collect2: error: ld returned 1 exit status

如果您在一个步骤中编译和链接，则会得到相同的结果，例如：

$ gcc -o eg1 -I. -L. -lmy_lib eg1.c
/tmp/ccQk1tvs.o: In function `main':
eg1.c:(.text+0x5): undefined reference to `hw'
collect2: error: ld returned 1 exit status

一个涉及共享系统库的最小示例，即压缩库libz

例如2.c

#include <zlib.h>
#include <stdio.h>

int main()
{
    printf("%s\n",zlibVersion());
    return 0;
}

编译程序：

$ gcc -c -o eg2.o eg2.c

尝试将程序与libz链接并失败：

$ gcc -o eg2 -lz eg2.o 
eg2.o: In function `main':
eg2.c:(.text+0x5): undefined reference to `zlibVersion'
collect2: error: ld returned 1 exit status

如果您一次编译并链接：

$ gcc -o eg2 -I. -lz eg2.c
/tmp/ccxCiGn7.o: In function `main':
eg2.c:(.text+0x5): undefined reference to `zlibVersion'
collect2: error: ld returned 1 exit status

示例2的一个变体涉及pkg配置：

$ gcc -o eg2 $(pkg-config --libs zlib) eg2.o 
eg2.o: In function `main':
eg2.c:(.text+0x5): undefined reference to `zlibVersion'

你做错了什么？

在要链接的对象文件和库序列中程序，您将库放在引用的对象文件之前他们您需要将库放在引用对他们来说。

正确链接示例1：

$ gcc -o eg1 eg1.o -L. -lmy_lib

成功：

$ ./eg1 
Hello World

正确链接示例2：

$ gcc -o eg2 eg2.o -lz

成功：

$ ./eg2 
1.2.8

正确链接示例2 pkg配置变体：

$ gcc -o eg2 eg2.o $(pkg-config --libs zlib) 
$ ./eg2
1.2.8

解释

从这里开始，阅读是可选的。

默认情况下，GCC在您的发行版上生成的链接命令，在中从左到右使用链接中的文件命令行序列。当它发现一个文件引用了某个并且不包含其定义，to将搜索定义在更右边的文件中。如果它最终找到了定义解析引用。如果任何引用在结束时仍未解决，链接失败：链接器没有向后搜索。

首先，示例1，使用静态库my_lib.a

静态库是对象文件的索引存档。当链接器在链接序列中找到-lmy-lib，并指出这是指到静态库/libmy_lib.a，它想知道您的程序是否需要libmy_lib.a中的任何对象文件。

libmy_lib.a中只有一个对象文件，即my_lib.o，并且只定义了一个对象在my_lib.o中，即函数hw。

链接器将决定您的程序需要my_lib.o，如果并且仅当它已经知道您的程序在一个或多个对象文件中引用hw添加到程序中，并且没有添加任何对象文件包含hw的定义。

如果这是真的，那么链接器将从库中提取my_lib.o的副本，并将其添加到您的程序中。然后，您的程序包含hw的定义，因此其对hw的引用被解析。

当您尝试链接程序时，如：

$ gcc -o eg1 -L. -lmy_lib eg1.o

链接器在看到时没有将eg1.o添加到程序中-lmy_库。因为在这一点上，它还没有看到eg1.o。您的程序尚未引用hw:it根本没有做任何引用，因为它做的所有引用在eg1.o中。

因此，链接器不会将my_lib.o添加到程序中，并且没有其他内容用于libmy_lib.a。

接下来，它找到eg1.o，并将其添加到程序中。中的对象文件链接序列总是添加到程序中。现在，该程序使对hw的引用，并且不包含hw的定义；但是链接序列中没有任何内容可以提供缺失释义对hw的引用最终无法解析，链接失败。

第二，示例2，使用共享库libz

共享库不是对象文件或类似文件的存档更像是一个没有主功能的程序而是公开它定义的多个其他符号程序可以在运行时使用它们。

今天，许多Linux发行版配置其GCC工具链，以便其语言驱动程序（GCC、g++、gfortran等）指示系统链接器（ld）根据需要链接共享库。你有一个这样的发行版。

这意味着当链接器在链接序列中找到-lz，并发现这是指到共享库（例如）/usr/lib/x86_64-linux-gnu/libz，它想知道它添加到程序中的任何尚未定义的引用是否具有libz导出的定义

如果这是真的，那么链接器将不会从libz和将它们添加到您的程序中；相反，它只会修改程序的代码从而：-

在运行时，系统程序加载器会将libz的副本加载到无论何时加载程序的副本，都可以执行与程序相同的过程。在运行时，每当程序引用libz，该引用使用中libz副本导出的定义相同的过程。

您的程序只想引用一个由libz导出的定义，即函数zlibVersion，在eg2.c中仅引用一次。如果链接器将该引用添加到程序中，然后找到定义由libz导出，引用被解析

但当您尝试链接程序时，如：

gcc -o eg2 -lz eg2.o

事件的顺序是错误的，其方式与示例1相同。在链接器找到-lz时，没有对任何内容的引用在节目中：他们都在eg2.o中，这还没有被看到。所以链接器决定它不适用于libz。当它达到eg2.o时，将其添加到程序中，然后对zlibVersion有未定义的引用，链接序列完成；该引用未解析，链接失败。

最后，示例2的pkg配置变体现在有了一个显而易见的解释。壳体膨胀后：

gcc -o eg2 $(pkg-config --libs zlib) eg2.o

变为：

gcc -o eg2 -lz eg2.o

这再次只是示例2。

我可以重复示例1中的问题，但不能重复示例2中的问题

联动装置：

gcc -o eg2 -lz eg2.o

对你来说很好！

（或者：在Fedora 23上，这种链接很好，但在Ubuntu 16.04上失败了）

这是因为链接工作的发行版是不配置其GCC工具链以根据需要链接共享库。

过去，类unix系统链接静态和共享是很正常的不同的规则。链接序列中的静态库已链接但是共享库是无条件链接的。

这种行为在链接时是经济的，因为链接器不必考虑程序是否需要共享库：如果是共享库，大多数链接中的大多数库都是共享库。但也有缺点：-

这在运行时是不经济的，因为它会导致共享库与程序一起加载，即使不需要它们。静态库和共享库的不同链接规则可能会令人困惑对于不熟练的程序员，他们可能不知道-lfo是否在他们的联系中将解析为/some/where/libfoo.a或/some/wwhere/libfoo.so，并且可能不理解共享库和静态库之间的区别无论如何

这种权衡导致了今天的分裂局面。一些发行版有更改了共享库的GCC链接规则，以便根据需要这一原则适用于所有图书馆。一些发行版沿用了旧版本方法

为什么即使同时编译和链接，我仍然会遇到这个问题？

如果我这样做：

$ gcc -o eg1 -I. -L. -lmy_lib eg1.c

当然，gcc必须首先编译eg1.c，然后链接生成的带有libmy_lib.a的对象文件，那么它怎么可能不知道该对象文件在进行链接时是否需要？

因为使用单个命令编译和链接不会更改连杆顺序。

当您运行上面的命令时，gcc发现您需要编译+链接。因此，在幕后，它生成一个编译命令，并运行然后生成一个链接命令并运行它，就像您运行了两个命令：

$ gcc -I. -c -o eg1.o eg1.c
$ gcc -o eg1 -L. -lmy_lib eg1.o

因此，如果运行这两个命令，链接就会失败。这个您在失败中注意到的唯一区别是gcc生成了编译+链接情况下的临时对象文件，因为您没有告诉它使用eg1.o.我们看到：

/tmp/ccQk1tvs.o: In function `main'

而不是：

eg1.o: In function `main':

另请参见

指定相互依赖的链接库的顺序错误

将相互依赖的库按错误的顺序排列只是一种方法在其中，您可以获取需要对即将到来的事物进行定义的文件在链接中晚于提供定义的文件。将库放在引用它们的对象文件是犯同样错误的另一种方式。

我的例子：

头文件

class GameCharacter : public GamePart
{
    private:
        static vector<GameCharacter*> characterList;
...
}

.cpp文件：

vector<GameCharacter*> characterList;

这产生了“未定义”加载程序错误，因为“characterList”被声明为静态成员变量，但被定义为全局变量。

我加上这个是因为——虽然其他人在一长串需要注意的事情中列出了这个案例——但这个列表并没有给出示例。这是一个更值得寻找的例子，尤其是在C++中。

修复方法是向全局变量添加限定以定义静态数据成员：

vector<GameCharacter*> GameCharacter::characterList;

同时保持收割台相同。

已声明但未定义变量或函数。

典型的变量声明是

extern int x;

由于这只是一个声明，因此需要一个单独的定义。相应的定义如下：

int x;

例如，以下内容将生成错误：

extern int x;
int main()
{
    x = 0;
}
//int x; // uncomment this line for successful definition

类似的注释适用于函数。声明函数而不定义它会导致错误：

void foo(); // declaration only
int main()
{
   foo();
}
//void foo() {} //uncomment this line for successful definition

请注意，您实现的函数与您声明的函数完全匹配。例如，您可能有不匹配的简历限定符：

void foo(int& x);
int main()
{
   int x;
   foo(x);
}
void foo(const int& x) {} //different function, doesn't provide a definition
                          //for void foo(int& x)
                          

不匹配的其他示例包括

函数/变量在一个命名空间中声明，在另一个命名空间定义。函数/变量声明为类成员，定义为全局（反之亦然）。函数返回类型、参数编号和类型以及调用约定并不完全一致。

来自编译器的错误消息通常会给出已声明但从未定义的变量或函数的完整声明。将其与您提供的定义进行比较。确保每个细节都匹配。

当您使用错误的编译器构建程序时

如果您使用的是gcc或clang编译器套件，则应根据所使用的语言使用正确的编译器驱动程序。使用g++或clang++编译和链接C++程序。改用gcc或clang将导致对C++标准库符号的引用未定义。例子：

$ gcc -o test test.cpp    
/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/../../../../x86_64-pc-linux-gnu/bin/ld: /tmp/ccPv7MvI.o: warning: relocation against `_ZSt4cout' in read-only section `.text' 
/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/../../../../x86_64-pc-linux-gnu/bin/ld: /tmp/ccPv7MvI.o: in function `main': test.cpp:(.text+0xe): undefined reference to `std::cout' 
/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/../../../../x86_64-pc-linux-gnu/bin/ld: test.cpp:(.text+0x13): undefined reference to `std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)' 
/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/../../../../x86_64-pc-linux-gnu/bin/ld: /tmp/ccPv7MvI.o: in function `__static_initialization_and_destruction_0(int, int)': 
test.cpp:(.text+0x43): undefined reference to `std::ios_base::Init::Init()' 
/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/../../../../x86_64-pc-linux-gnu/bin/ld: test.cpp:(.text+0x58): undefined reference to `std::ios_base::Init::~Init()' 
/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/../../../../x86_64-pc-linux-gnu/bin/ld: warning: creating DT_TEXTREL in a PIE 
collect2: error: ld returned 1 exit status