C++ 什么是未定义的引用/未解决的外部符号错误？如何修复它？
什么是未定义的引用/未解决的外部符号错误？什么是常见的原因和如何修复/阻止它们？< /P> < P>编译C++程序发生在几个步骤中，如2.2：< /P>所指定的。 翻译语法规则的优先顺序由以下阶段规定[见脚注] 物理源文件字符以实现定义的方式映射到基本源字符集 在以下情况下，为行尾指示器引入新行字符： 必需的[剪报] 删除紧跟着新行字符的反斜杠字符\的每个实例，将物理源行拼接到 形成逻辑源行。[剪报] 源文件被分解为预处理标记2.5和包含注释的空白字符序列。[剪报] 执行预处理指令，展开宏调用，并执行_Pragma一元运算符表达式。[剪报] 字符文字或字符串文字中的每个源字符集成员，以及每个转义序列和通用字符名 在字符文字或非原始字符串文字中，转换为 执行字符集的对应成员；[剪报] 相邻的字符串文字标记被连接起来。 分隔标记的空白字符不再有效。每个预处理令牌都转换为一个令牌。2.7. 这个 对生成的标记进行语法和语义分析并 翻译成一个翻译单位。[剪报] 翻译单元和实例化单元的组合如下：[SNIP] 解析所有外部实体引用。库组件链接以满足对中未定义的实体的外部引用 目前的翻译。所有此类翻译器输出都收集到 程序映像，其中包含在其 执行环境。重点矿山 [脚注]尽管在实践中不同的阶段可能会被折叠在一起，但实现的行为必须像这些单独的阶段一样C++ 什么是未定义的引用/未解决的外部符号错误？如何修复它？,c++,linker-errors,undefined-reference,c++-faq,unresolved-external,visual-studio,C++,Linker Errors,Undefined Reference,C++ Faq,Unresolved External,Visual Studio,什么是未定义的引用/未解决的外部符号错误？什么是常见的原因和如何修复/阻止它们？< /P> < P>编译C++程序发生在几个步骤中，如2.2：< /P>所指定的。 翻译语法规则的优先顺序由以下阶段规定[见脚注] 物理源文件字符以实现定义的方式映射到基本源字符集 在以下情况下，为行尾指示器引入新行字符： 必需的[剪报] 删除紧跟着新行字符的反斜杠字符\的每个实例，将物理源行拼接到 形成逻辑源行。[剪报] 源文件被分解为预处理标记2.5和包含注释的空白字符序列。[剪报] 执行预处理指令，展开宏调用，
g++ -o test objectFile1.o objectFile2.o -lLibraryName
g++ -o test objectFile1.o objectFile2.o -lLibraryName
struct X
{
virtual void foo();
};
struct Y : X
{
void foo() {}
};
struct A
{
virtual ~A() = 0;
};
struct B: A
{
virtual ~B(){}
};
extern int x;
void foo();
int main()
{
x = 0;
foo();
Y y;
B b;
}
g++ -o test objectFile1.o objectFile2.o -lLibraryName
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
A a; //destructor undefined
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)
struct X
{
virtual ~X() = 0;
};
struct Y : X
{
~Y() {}
};
int main()
{
Y y;
}
//X::~X(){} //uncomment this line for successful definition
struct X
{
virtual void foo();
};
struct Y : X
{
void foo() {}
};
int main()
{
Y y; //linker error although there was no call to X::foo
}
// graphics.lib
#include "common_math.h"
void draw(vec3 p) { ... } // vec3 comes from common_math.h
struct X
{
virtual ~X() = 0;
};
struct Y : X
{
~Y() {}
};
int main()
{
Y y;
}
//X::~X(){} //uncomment this line for successful definition
struct X
{
virtual void foo();
};
struct Y : X
{
void foo() {}
};
int main()
{
Y y; //linker error although there was no call to X::foo
}
// graphics.lib
#include "common_math.h"
void draw(vec3 p) { ... } // vec3 comes from common_math.h
struct A
{
~A();
};
void foo(); // declaration only
int main()
{
foo();
}
//void foo() {} //uncomment this line for successful definition
A a; //destructor undefined
struct A
{
~A() {}
};
A::~A() {}
void A::foo() {}
template<class T>
struct X
{
void foo();
};
int main()
{
X<int> x;
x.foo();
}
//differentImplementationFile.cpp
template<class T>
void X<T>::foo()
{
}
void foo();
int main()
{
foo();
}
C++链接器希望名称被损坏，因此必须声明函数为：
extern "C" void foo();
int main()
{
foo();
}
等效地，不是在C程序中定义，而是在C++中定义函数或变量空格FO，但用C连接定义：
extern "C" void foo();
extern "C" {
#include "cheader.h"
}
std::ostream& operator<< (std::ostream& os, const Foo<int>& a) {/*...*/}
// 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
}
template <typename T>
class Foo {
template <typename T1>
friend std::ostream& operator<<(std::ostream& os, const Foo<T1>& a);
// ...
};
#ifdef THIS_MODULE
#define DLLIMPEXP __declspec(dllexport)
#else
#define DLLIMPEXP __declspec(dllimport)
#endif
DLLIMPEXP void foo();
__declspec(dllexport) void foo();
__declspec(dllimport) void foo();
class DLLIMPEXP X
{
};
// main.exe
#include "other/common_math.h"
#include "graphics.h"
int main() {
draw(...);
}
为了解决这个问题，我将MyProject构建为一个LIB，并将TestProject链接到这个.LIB文件，然后将生成的.LIB文件复制粘贴到TestProject文件夹中。然后，我可以将MyProject重新构建为DLL。它正在编译，因为TestProject链接到的lib确实包含MyProject类中所有方法的代码 此外，如果您使用的是第三方库，请确保您具有正确的32/64位二进制文件指定相互依赖的链接库的顺序是错误的。 如果库相互依赖，则库的链接顺序确实很重要。通常，如果库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
g++ -c main.cpp foo.cpp gum.cpp
#pragma comment(lib, "libname.lib")
// 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;
}
$ g++ -c src1.cpp -o src1.o
$ g++ -c src2.cpp -o src2.o
$ g++ src1.o src2.o -o prog
$ g++ src1.o src2.o -o prog
$ 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
$ g++ -c src1.cpp -o src1.o
$ g++ -c src2.cpp -o src2.o
$ g++ src1.o src2.o -o prog
$ g++ src1.o src2.o -o prog
$ ./prog
123
$ ./prog
123456789
// 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
$ 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 _ZL14local_var_name
.comm _ZL14local_var_name,4,4
.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:
; ...
$ g++ -c src1.s -o src2.o
$ readelf --symbols src1.o
8: 0000000000000000 4 OBJECT GLOBAL DEFAULT 3 local_var_name
$ ./prog
123
$ ./prog
123456789
INPUT (libtbb.so.2)
cp libtbb.so.2 libtbb.so
或者您可以将-l参数替换为.so的完整路径，例如，代替-ltbb do/home/foo/tbb-4.3/linux/lib/intel64/gcc4.4/libtbb.so.2这是每个VC++程序员反复看到的最令人困惑的错误消息之一。让我们先把事情弄清楚 什么是符号？ 简而言之，符号就是名称。它可以是一个变量名、函数名、类名、TyWIFF名称，或者除了C++语言中的那些名称和符号之外的任何东西。它是用户定义的或由依赖项库引入的，而依赖项库是另一个用户定义的 什么是外部的？ 在VC++中，每个源文件.cpp、.c等都被视为一个翻译单元，编译器一次编译一个单元，并为当前翻译单元生成一个目标文件.obj。请注意，此源文件包含的每个头文件都将被预处理，并将被视为此翻译单元的一部分。翻译单元中的所有内容都被视为内部内容，其他所有内容都被视为外部内容。在C++中，可以使用诸如Extn、y*-DeScript、dLimPurt等关键字引用外部符号。 什么是“决心”？ “解决”是一个链接时间术语。在链接时，链接器尝试为对象文件中无法在内部找到其定义的每个符号查找外部定义。此搜索过程的范围包括： 编译时生成的所有对象文件 显式或隐式 指定为此建筑应用程序的其他依赖项。 这个搜索过程称为解析 最后，为什么没有解决外部符号？ 如果链接器找不到内部没有定义的符号的外部定义，则会报告未解析的外部符号错误 E.LNK2019的可能原因：未解决的外部符号错误。 我们已经知道，此错误是由于链接器未能找到外部符号的定义，可能的原因可分为： 定义存在 例如，如果我们在a.cpp中定义了一个名为foo的函数：
int foo()
{
return 0;
}
void foo();
假设你有一个C++项目，它有一个 一千个.cpp文件和一千个.h文件。假设该项目还依赖于十个静态库。假设我们在Windows上，我们在VisualStudio20xx中构建我们的项目。当您按Ctrl+F7 Visual Studio开始编译整个解决方案时，假设解决方案中只有一个项目 编辑的意义是什么 Visual Studio搜索文件.vcxproj并开始编译扩展名为.cpp的每个文件。编译顺序未定义。因此，您不能假定文件main.cpp是先编译的 如果.cpp文件依赖其他.h文件来查找符号 可以在文件.cpp中定义，也可以不定义 如果存在一个.cpp文件，编译器在其中找不到一个符号，则编译器时间错误将引发消息“找不到符号x” 对于扩展名为.cpp的每个文件，都会生成一个对象文件.o，Visual Studio还会将输出写入名为ProjectName.cpp.Clean.txt的文件中，该文件包含链接器必须处理的所有对象文件。 编译的第二步由链接器完成。链接器应该合并所有的目标文件，并最终生成输出，输出可以是可执行文件或库 链接项目的步骤 解析所有对象文件并找到仅在标题中声明的定义，例如：在前面的回答中提到的类的一个方法的代码，或者是类中成员的静态变量的初始化事件 如果在目标文件中找不到一个符号，则还会在其他库中搜索该符号。要将新库添加到项目，请选择“配置属性”->“VC++目录”->“库目录”，然后在此处指定用于搜索库的其他文件夹，并选择“配置属性”->“链接器”->“输入”指定该符号的名称图书馆 -如果链接器找不到您在一个.cpp中写入的符号，他会引发一个链接器时间错误，听起来像 错误LNK2001:未解析的外部符号无效\uuuu cdecl foovoid？foo@@YAXXZ 观察 一旦链接器找到一个符号，他就不会在其他库中搜索它 链接库的顺序确实很重要。 如果链接器在一个静态库中找到一个外部符号，他会在项目的输出中包含该符号。但是，如果该库是动态共享的，他不会在输出中包含代码符号，但可能会发生运行时崩溃 如何解决这种错误 编译器时间错误： 确保你的C++项目语法正确。 链接器时间错误 定义在头文件中声明的所有符号 使用pragma一次，允许编译器不包含一个头，如果它已经包含在当前编译的.cpp中 确保外部库中不包含可能与头文件中定义的其他符号冲突的符号 使用模板时，请确保在头文件中包含每个模板函数的定义，以允许编译器为任何实例化生成适当的代码。
由于人们似乎被引导到这个问题，当涉及到链接器错误时，我将在这里添加这个 GCC 5.2.0中出现链接器错误的一个可能原因是默认情况下选择了新的libstdc++库ABI 如果出现链接器错误，即未定义对涉及std:：\u cxx11命名空间或标记[abi:cxx11]中类型的符号的引用，则可能表示您正在尝试将使用不同值为_GLIBCXX\u USE\u cxx11\u abi宏编译的对象文件链接在一起。这通常发生在链接到使用较旧版本的GCC编译的第三方库时。如果无法使用新的ABI重建第三方库，则需要使用旧的ABI重新编译代码 因此，如果您在5.1.0之后切换到GCC时突然出现链接器错误，这将是一件需要检查的事情。清理并重建 对构建的清理可以清除以前构建、失败构建、不完整构建和其他构建系统相关构建问题遗留下来的死木头 通常，IDE或构建将包括某种形式的清除功能，但这可能没有正确配置（例如在手动生成文件中），或者可能会失败（例如，中间或生成的二进制文件是只读的） 清理完成后，验证清理是否成功，以及是否已成功删除所有生成的中间文件，例如自动生成的文件 这一过程可以看作是最后的手段，但往往是良好的第一步；特别是如果与错误相关的代码最近已在本地或从源存储库添加。交友模板。。。 给定带有友元运算符或函数的模板类型的代码段
template <typename T>
class Foo {
friend std::ostream& operator<< (std::ostream& os, const Foo<T>& a);
};
extern "C" {
#include "cheader.h"
}
std::ostream& operator<< (std::ostream& os, const Foo<int>& a) {/*...*/}
// 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
}
template <typename T>
class Foo {
template <typename T1>
friend std::ostream& operator<<(std::ostream& os, const Foo<T1>& a);
// ...
};
#define UNICODE
#define _UNICODE
/DUNICODE /D_UNICODE
// header1.h
typedef int Number;
void foo(Number);
// header2.h
typedef float Number;
void foo(Number); // this only looks the same lexically
struct X
{
virtual ~X() = 0;
};
struct Y : X
{
~Y() {}
};
int main()
{
Y y;
}
//X::~X(){} //uncomment this line for successful definition
struct X
{
virtual void foo();
};
struct Y : X
{
void foo() {}
};
int main()
{
Y y; //linker error although there was no call to X::foo
}
// graphics.lib
#include "common_math.h"
void draw(vec3 p) { ... } // vec3 comes from common_math.h
// main.exe
#include "other/common_math.h"
#include "graphics.h"
int main() {
draw(...);
}
// header1.h
typedef int Number;
void foo(Number);
// header2.h
typedef float Number;
void foo(Number); // this only looks the same lexically
$ gcc -I. -c -o eg1.o eg1.c
$ gcc -c -o eg2.o eg2.c
$ 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 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 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
$ 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 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
$ gcc -o eg1 eg1.o -L. -lmy_lib
$ gcc -o eg2 eg2.o -lz
$ gcc -o eg2 eg2.o $(pkg-config --libs zlib)
$ ./eg2
1.2.8
$ ./eg1
Hello World
$ ./eg2
1.2.8
$ gcc -o eg1 eg1.o -L. -lmy_lib
$ gcc -o eg2 eg2.o -lz
$ gcc -o eg2 eg2.o $(pkg-config --libs zlib)
$ ./eg2
1.2.8
$ ./eg1
Hello World
$ ./eg2
1.2.8
$ gcc -o eg1 eg1.o -L. -lmy_lib
$ gcc -o eg2 eg2.o -lz
$ gcc -o eg2 eg2.o $(pkg-config --libs zlib)
$ ./eg2
1.2.8
$ gcc -o eg1 -L. -lmy_lib eg1.o
gcc -o eg2 -lz eg2.o
$ gcc -o eg1 -L. -lmy_lib eg1.o
gcc -o eg2 -lz eg2.o
gcc -o eg2 $(pkg-config --libs zlib) eg2.o
gcc -o eg2 -lz eg2.o
gcc -o eg2 -lz eg2.o
$ gcc -o eg1 -I. -L. -lmy_lib eg1.c
$ gcc -I. -c -o eg1.o eg1.c
$ gcc -o eg1 -L. -lmy_lib eg1.o
eg1.o: In function `main':
// file1.cpp
const int test = 5; // in C++ same as "static const int test = 5"
int test2 = 5;
// file2.cpp
extern const int test;
extern int test2;
void foo()
{
int x = test; // linker error in C++ , no error in C
int y = test2; // no problem
}
extern const int test;
extern int test2;
或者，可以在file1.cpp中使用显式extern声明const变量，即使这是一个有多个可接受答案的非常老的问题，我想与大家分享如何解决一个模糊的未定义错误引用 图书馆的不同版本 我使用别名来表示std:：filesystem:：path:filesystem自C++17以来就在标准库中，但我的程序也需要在C++14中编译，因此我决定使用变量别名：
#if (defined _GLIBCXX_EXPERIMENTAL_FILESYSTEM) //is the included filesystem library experimental? (C++14 and newer: <experimental/filesystem>)
using path_t = std::experimental::filesystem::path;
#elif (defined _GLIBCXX_FILESYSTEM) //not experimental (C++17 and newer: <filesystem>)
using path_t = std::filesystem::path;
#endif
$ gcc -I. -c -o eg1.o eg1.c
$ gcc -o eg1 -L. -lmy_lib eg1.o
# -D shows (global) dynamic symbols that can be used from the outside of XXX.so
nm -D XXX.so | grep MY_SYMBOL
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(){
...
}
#ifdef BUILDING_DLL
#define DLL_PUBLIC __declspec(dllexport)
#else
#define DLL_PUBLIC __declspec(dllimport)
#endif
>>> objdump -t XXXX.o | grep hidden
0000000000000000 g F .text 000000000000000b .hidden HIDDEN_SYMBOL1
000000000000000b g F .text 000000000000000b .hidden HIDDEN_SYMBOL2
完整地说，这个答案应该提到GCC的可见性和Windows“.def”文件，因为它们也会影响符号名称和存在。@rubenvb我很久没有使用过.def文件了。请随意添加答案或编辑此答案。正确-当库具有循环依赖关系时会发生这种情况。我扩展了您的答案并在主答案中进行了链接。谢谢。就个人而言，我认为MS linker错误消息和GCC错误一样可读。它们还有一个优点，即为未解析的外部对象包含损坏和未混合的名称。当您需要直接查看库或对象文件以了解问题所在（例如，调用约定不匹配）时，使用损坏的名称会很有帮助。此外，我不确定是什么版本的MSVC在这里产生了错误，但较新的版本包含了引用未解析外部符号的函数的名称，包括“已损坏”和“未混合”。David Drysdale写了一篇关于链接器如何工作的伟大文章：。考虑到这个问题的主题，我认为它可能会很有用。@TankorSmash是否使用gcc？更准确地说，@luchian如果您添加正确的，修复上述错误，那就太好了。我会在列表中添加一个常见的情况-只是不将文件添加到其中使用的MSVC项目中：@LuchianGrigore“请随意添加答案”我更愿意在您的主要答案中添加相关链接，如果您希望允许.@jave.web：在这种情况发生时，程序员通常会注意到他没有这个指针，也没有访问类成员的权限。完成编译是非常罕见的，只有在非静态成员函数缺少其限定名时，链接才会失败。@AlbertvanderHorst这个问题太笼统了，不能接受有用的答案。下面的答案是否有用？它们可能有用，正如许多问题的答案被标记为过于笼统一样，老实说，我希望看到我们对大多数新用户提出的要求是最低限度的重复性示例。我的意思不是什么，只是-我们不能期望人们遵守我们自己不知道的规则。我不得不指出，这通常是因为没有主函数而不是没有WinMain。有效的C++程序需要一个主程序。
标题中的d可以在Just Think中找到，您可能希望强调这两种方法都是可能的，而dtor实际上并不是一个例外。乍一看，你的措辞并不明显。这似乎过于具体——也许一个新的线程会是这个答案的更好的地方。@LuchianGrigore:我确实想发帖，因为那个问题正是这个问题，但它被标记为这个问题的副本，所以我无法在那里回答它。所以我把我的答案贴在这里了。这个问题已经有了公认的答案。它被标记为重复，因为上面列出了一般原因。如果我们在这里对未包含的库的每个问题都有一个答案，会发生什么？@LuchianGrigore：这个问题不是特定于库的，它会影响使用Visual Studio包管理系统的所有库。我碰巧发现了另一个问题，因为我们都有libpng的问题。对于libxml2、libiconv和glew的相同解决方案，我也遇到了同样的问题。这个问题是关于VisualStudio的包管理系统的问题，我的回答解释了原因并提供了解决方法。有人只是看到了未解决的外部问题，并认为这是一个标准的链接器问题，而实际上是一个包管理问题。或者相反，如果您开发一个C库，一个很好的规则是通过使用ifdef u cplusplus[\n]externC{[\n]endif和ifdef u cplusplus[\n]}[\n]endif包围所有导出的声明来保护头文件[n]是真正的回车，但我不能正确地写在评论中。正如上面的评论，“创建混合语言标题”部分帮助：真的帮助了我！这是我的情况，当我寻找这个问题时，如果你把你的C++ C++头文件意外地包含在外部C：{include}。你的答案不是针对visual studio的吗？这个问题没有指定任何IDE/编译器工具，因此你的答案对于非visual studio部分来说毫无用处。你是对的。但是每个IDE编译/链接过程中的每一个都有一点不同。但是文件的处理方式完全相同，即使g++在运行时也会执行相同的操作标记。问题实际上不是关于IDE，而是关于链接问题的答案。链接问题与IDE无关，而是与编译器和构建过程有关。是的。但是构建/链接过程是在Microsoft for VS/Eclipse/Net Beans提供的g++/Visual Studiocompiler中完成的，同样，相信您的工具是broken很可能会引导您远离真正的原因。您犯错误的可能性比编译器导致问题的可能性要大得多。清理解决方案或重新创建生成配置可能会修复生成错误，但这并不意味着编译器中存在错误。链接结果表明这是一个错误，但未确认由Microsoft提供，不可复制。@JDiMatteo此问题有21个答案，因此大量答案不太可能成为解决方案。如果您忽略所有低于您的可能性阈值的答案，则此页面实际上将变得毫无用处，因为大多数常见情况都很容易被发现。我很好奇美国的事实是，在我的例子中，我有一个依赖于共享库的对象文件。我必须修改生成文件，并将库放在Debian上GCC4.8.4的对象之后。在Centos 6.5上GCC4.4的生成文件工作正常。在VS中，与头文件中包含的内容不匹配的cpp文件也属于o类f缺少定义。您应该使用nm-CD或nm-gCD来查看外部符号。另请参见GCC wiki上的。感谢您的系统性解释。在阅读完这篇文章后，我可以理解这里的其他答案。如果您可以明确说明GCC main.c而不是GCC main.c other.c的常见错误，这将是一件好事，初学者通常会这么做在他们的项目变得如此庞大以致于构建.o文件之前，我第一次尝试使用另一个文件中的一些UTIL编写cpp代码，这些步骤帮助我更清楚地理解，所以谢谢！