什么是未定义的参考/未解析的外部符号错误？常见原因是什么？如何解决/预防？
当前回答
正在添加模板。。。
给定带有友元运算符（或函数）的模板类型的代码片段；
template <typename T>
class Foo {
friend std::ostream& operator<< (std::ostream& os, const Foo<T>& a);
};
运算符<<被声明为非模板函数。对于与Foo一起使用的每种类型T，都需要有一个非模板运算符<<。例如，如果声明了一个类型Foo＜int＞，那么必须有如下的运算符实现：；
std::ostream& operator<< (std::ostream& os, const Foo<int>& a) {/*...*/}
由于它未实现，链接器无法找到它并导致错误。
要更正此问题，可以在Foo类型之前声明一个模板运算符，然后将适当的实例化声明为友元。语法有点尴尬，但看起来如下：；
// forward declare the Foo
template <typename>
class Foo;
// forward declare the operator <<
template <typename T>
std::ostream& operator<<(std::ostream&, const Foo<T>&);
template <typename T>
class Foo {
friend std::ostream& operator<< <>(std::ostream& os, const Foo<T>& a);
// note the required <> ^^^^
// ...
};
template <typename T>
std::ostream& operator<<(std::ostream&, const Foo<T>&)
{
// ... implement the operator
}
上述代码将运算符的友谊限制为Foo的相应实例化，即运算符＜＜＜int＞实例化被限制为访问Foo＜int＞的实例化的私有成员。
备选方案包括：；
允许友谊扩展到模板的所有实例化，如下所示；模板＜typename T＞Foo类{模板＜typename T1＞朋友std:：ostream&operator<<（std:：estream&os，const Foo<T1>/a）；// ...};或者，运算符<<的实现可以在类定义内内联完成；模板＜typename T＞Foo类{朋友std:：ostream&operator<<（std:：estream&os，const Foo&a）{ /*...*/ }// ...};
注意，当运算符（或函数）的声明仅出现在类中时，该名称不适用于“普通”查找，仅适用于cppreference中的依赖于参数的查找；
首先在类或类模板X中的友元声明中声明的名称将成为X最内部封闭命名空间的成员，但除非在命名空间范围内提供了匹配声明，否则无法进行查找（考虑X的依赖于参数的查找除外）。。。
cppreference和C++常见问题解答中有关于模板朋友的进一步阅读。
显示上述技术的代码列表。
作为失败代码示例的旁注；g++警告如下
警告：friend声明“std:：ostream&operator<<（…）”声明非模板函数[-Wnon-template friend]注意：（如果这不是您想要的，请确保函数模板已经声明，并在此处的函数名称后面添加<>）
其他回答
函数或类方法在源文件中使用内联说明符定义。
例如：-
主.cpp
#include "gum.h"
#include "foo.h"
int main()
{
gum();
foo f;
f.bar();
return 0;
}
foo.h（1）
#pragma once
struct foo {
void bar() const;
};
口香糖.h（1）
#pragma once
extern void gum();
foo.cpp（1）
#include "foo.h"
#include <iostream>
inline /* <- wrong! */ void foo::bar() const {
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
gum.cpp（1）
#include "gum.h"
#include <iostream>
inline /* <- wrong! */ void gum()
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
如果指定gum（类似地，foo:：bar）在其定义中是内联的，那么编译器将通过以下方式内联gum（如果它选择）：-
没有任何独特的口香糖定义，因此不发出任何符号，链接器可以通过该符号引用口香糖的定义，而是将所有对gum的调用替换为编译后的gum主体的内联副本。
因此，如果在源文件gum.cpp中内联定义gum，则编译为对象文件gum.o，其中所有对gum的调用都是内联的并且没有定义接头可以指代口香糖的符号。当你将gum.o与另一个对象文件（例如main.o）链接到程序中引用外部符号gum时，链接器无法解析这些参考文献。因此连杆失效：
编译：
g++ -c main.cpp foo.cpp gum.cpp
链接：
$ g++ -o prog main.o foo.o gum.o
main.o: In function `main':
main.cpp:(.text+0x18): undefined reference to `gum()'
main.cpp:(.text+0x24): undefined reference to `foo::bar() const'
collect2: error: ld returned 1 exit status
如果编译器可以在调用gum的每个源文件中看到它的定义，则只能将gum定义为内联。这意味着它的内联定义需要存在于包含在每个源文件中的头文件中您可以在其中调用gum。做两件事之一：
要么不内联定义
从源文件定义中删除内联说明符：
foo.cpp（2）
#include "foo.h"
#include <iostream>
void foo::bar() const {
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
gum.cpp（2）
#include "gum.h"
#include <iostream>
void gum()
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
重新生成：
$ g++ -c main.cpp foo.cpp gum.cpp
imk@imk-Inspiron-7559:~/develop/so/scrap1$ g++ -o prog main.o foo.o gum.o
imk@imk-Inspiron-7559:~/develop/so/scrap1$ ./prog
void gum()
void foo::bar() const
成功
或正确内联
头文件中的内联定义：
foo.h（2）
#pragma once
#include <iostream>
struct foo {
void bar() const { // In-class definition is implicitly inline
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
};
// Alternatively...
#if 0
struct foo {
void bar() const;
};
inline void foo::bar() const {
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
#endif
口香糖.h（2）
#pragma once
#include <iostream>
inline void gum() {
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
现在我们不需要foo.cpp或gum.cpp：
$ g++ -c main.cpp
$ g++ -o prog main.o
$ ./prog
void gum()
void foo::bar() const
我在头文件中声明函数的原型时遇到了这个问题：
int createBackground（VertexArray rVA，IntRect arena）；
但随后使用具有第一个参数的引用在其他地方定义函数：
int createBackground（VertexArray&rVA，IntRect arena）｛｝
原型没有在第一个参数中使用引用，而定义是，这一事实导致了这个问题。当我将两者都更改为正确匹配包含引用或不包含引用时，问题得到了解决。
干杯
班级成员：
纯虚拟析构函数需要实现。
声明析构函数pure仍然需要定义它（与常规函数不同）：
struct X
{
virtual ~X() = 0;
};
struct Y : X
{
~Y() {}
};
int main()
{
Y y;
}
//X::~X(){} //uncomment this line for successful definition
这是因为在隐式销毁对象时调用基类析构函数，因此需要定义。
虚拟方法必须实现或定义为纯方法。
这类似于没有定义的非虚拟方法，增加了如下推理：纯声明会生成一个虚拟vtable，您可能会在不使用函数的情况下得到链接器错误：
struct X
{
virtual void foo();
};
struct Y : X
{
void foo() {}
};
int main()
{
Y y; //linker error although there was no call to X::foo
}
要使其工作，请将X:：foo（）声明为纯：
struct X
{
virtual void foo() = 0;
};
非虚拟类成员
即使未明确使用，也需要定义某些成员：
struct A
{
~A();
};
以下内容将产生错误：
A a; //destructor undefined
实现可以在类定义本身中内联：
struct A
{
~A() {}
};
或外部：
A::~A() {}
如果实现在类定义之外，但在头中，则必须将方法标记为内联，以防止多重定义。
如果使用，则需要定义所有使用的成员方法。
一个常见的错误是忘记限定名称：
struct A
{
void foo();
};
void foo() {}
int main()
{
A a;
a.foo();
}
定义应为
void A::foo() {}
静态数据成员必须在类外部的单个转换单元中定义：
struct X
{
static int x;
};
int main()
{
int x = X::x;
}
//int X::x; //uncomment this line to define X::x
可以为类定义中的整型或枚举类型的静态常量数据成员提供初始值设定项；然而，odr使用这个成员仍然需要如上所述的命名空间范围定义。C++11允许在类内初始化所有静态常量数据成员。
我的例子：
头文件
class GameCharacter : public GamePart
{
private:
static vector<GameCharacter*> characterList;
...
}
.cpp文件：
vector<GameCharacter*> characterList;
这产生了“未定义”加载程序错误，因为“characterList”被声明为静态成员变量，但被定义为全局变量。
我加上这个是因为——虽然其他人在一长串需要注意的事情中列出了这个案例——但这个列表并没有给出示例。这是一个更值得寻找的例子，尤其是在C++中。
修复方法是向全局变量添加限定以定义静态数据成员：
vector<GameCharacter*> GameCharacter::characterList;
同时保持收割台相同。
什么是“未定义的引用/未解析的外部符号”
我将尝试解释什么是“未定义的引用/未解析的外部符号”。
注意：我使用的是g++和Linux，所有示例都是针对它的
例如，我们有一些代码
// src1.cpp
void print();
static int local_var_name; // 'static' makes variable not visible for other modules
int global_var_name = 123;
int main()
{
print();
return 0;
}
and
// src2.cpp
extern "C" int printf (const char*, ...);
extern int global_var_name;
//extern int local_var_name;
void print ()
{
// printf("%d%d\n", global_var_name, local_var_name);
printf("%d\n", global_var_name);
}
生成对象文件
$ g++ -c src1.cpp -o src1.o
$ g++ -c src2.cpp -o src2.o
在汇编程序阶段之后，我们有一个对象文件，其中包含要导出的任何符号。看看这些符号
$ readelf --symbols src1.o
Num: Value Size Type Bind Vis Ndx Name
5: 0000000000000000 4 OBJECT LOCAL DEFAULT 4 _ZL14local_var_name # [1]
9: 0000000000000000 4 OBJECT GLOBAL DEFAULT 3 global_var_name # [2]
我拒绝了输出中的一些行，因为它们无关紧要
因此，我们看到要导出的以下符号。
[1] - this is our static (local) variable (important - Bind has a type "LOCAL")
[2] - this is our global variable
src2.cpp不导出任何内容，我们没有看到它的符号
链接我们的对象文件
$ g++ src1.o src2.o -o prog
并运行它
$ ./prog
123
Linker看到导出的符号并将其链接起来
// src2.cpp
extern "C" int printf (const char*, ...);
extern int global_var_name;
extern int local_var_name;
void print ()
{
printf("%d%d\n", global_var_name, local_var_name);
}
并重建对象文件
$ g++ -c src2.cpp -o src2.o
好的（没有错误），因为我们只构建对象文件，链接还没有完成。尝试链接
$ g++ src1.o src2.o -o prog
src2.o: In function `print()':
src2.cpp:(.text+0x6): undefined reference to `local_var_name'
collect2: error: ld returned 1 exit status
发生这种情况是因为我们的local_var_name是静态的，即它对其他模块不可见。现在更深入。获取翻译阶段输出
$ g++ -S src1.cpp -o src1.s
// src1.s
look src1.s
.file "src1.cpp"
.local _ZL14local_var_name
.comm _ZL14local_var_name,4,4
.globl global_var_name
.data
.align 4
.type global_var_name, @object
.size global_var_name, 4
global_var_name:
.long 123
.text
.globl main
.type main, @function
main:
; assembler code, not interesting for us
.LFE0:
.size main, .-main
.ident "GCC: (Ubuntu 4.8.2-19ubuntu1) 4.8.2"
.section .note.GNU-stack,"",@progbits
所以，我们看到local_var_name没有标签，这就是链接器找不到它的原因。但我们是黑客：），我们可以修复它。在文本编辑器中打开src1.s并更改
.local _ZL14local_var_name
.comm _ZL14local_var_name,4,4
to
.globl local_var_name
.data
.align 4
.type local_var_name, @object
.size local_var_name, 4
local_var_name:
.long 456789
也就是说，你应该像下面这样
.file "src1.cpp"
.globl local_var_name
.data
.align 4
.type local_var_name, @object
.size local_var_name, 4
local_var_name:
.long 456789
.globl global_var_name
.align 4
.type global_var_name, @object
.size global_var_name, 4
global_var_name:
.long 123
.text
.globl main
.type main, @function
main:
; ...
我们已经更改了localvarname的可见性，并将其值设置为456789。尝试从中构建对象文件
$ g++ -c src1.s -o src2.o
好，请参阅readelf输出（符号）
$ readelf --symbols src1.o
8: 0000000000000000 4 OBJECT GLOBAL DEFAULT 3 local_var_name
现在local_var_name具有绑定GLOBAL（以前是local）
link
$ g++ src1.o src2.o -o prog
并运行它
$ ./prog
123456789
好的，我们破解它：）
因此，当链接器在对象文件中找不到全局符号时，就会发生“未定义的引用/未解析的外部符号错误”。
