不支持链接器脚本的GNUld包装器

一些.so文件实际上是GNU ld链接器脚本，例如libtbb.so文件是一个ASCII文本文件，其内容如下：

INPUT (libtbb.so.2)

一些更复杂的构建可能不支持这一点。例如，如果在编译器选项中包含-v，则可以看到mainwin gcc包装器mwdip丢弃要链接的库的详细输出列表中的链接器脚本命令文件。

cp libtbb.so.2 libtbb.so

或者可以用.so的完整路径替换-l参数，例如，代替-ltbb-do/home/foo/tbb-4.3/linux/lib/intel64/gcc4.4/libtb.so.2

UNICODE定义不一致

Windows UNICODE构建时，TCHAR等被定义为wchar_t等。如果不使用UNICODE进行构建，则TCHAR被定义为char等。这些UNICODE和_UNICODE定义会影响所有“t”字符串类型；LPTSTR、LPCTSTR及其麋鹿。

构建一个定义了UNICODE的库，并试图将其链接到未定义UNICODE项目中，将导致链接器错误，因为TCHAR的定义将不匹配；char与wchar_t。

错误通常包括一个带有char或wchar_t派生类型的值的函数，这些类型也可能包括std:：basic_string<>等。浏览代码中受影响的函数时，通常会引用TCHAR或std:：basic_string<TCHAR>等。这是一个信号，表明代码最初用于UNICODE和多字节字符（或“窄”）构建。

要更正此问题，请使用UNICODE（和_UNICODE）的一致定义构建所有必需的库和项目。

这可以通过以下两种方式实现：；#定义UNICODE#定义UNICODE或在项目设置中；项目财产>常规>项目默认值>字符集或在命令行上；/DUNICODE/D-UNICODE

如果不打算使用UNICODE，请确保未设置定义，和/或在项目中使用了多字符设置，并始终应用。

不要忘记在“发布”和“调试”版本之间保持一致。

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

典型的变量声明是

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)
                          

不匹配的其他示例包括

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

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

跨模块.dll（编译器特定）错误地导入/导出方法/类。

MSVS要求您使用__declspec（dllexport）和__declsspec（dllimport）指定要导出和导入的符号。

这种双重功能通常通过使用宏来实现：

#ifdef THIS_MODULE
#define DLLIMPEXP __declspec(dllexport)
#else
#define DLLIMPEXP __declspec(dllimport)
#endif

宏THIS_MODULE只能在导出函数的模块中定义。这样，声明：

DLLIMPEXP void foo();

扩展到

__declspec(dllexport) void foo();

并且告诉编译器导出函数，因为当前模块包含其定义。当将声明包含在不同的模块中时，它将扩展到

__declspec(dllimport) void foo();

并且告诉编译器，该定义位于链接到的一个库中（另请参见1）。

您可以使用类似的导入/导出类：

class DLLIMPEXP X
{
};

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

如果库相互依赖，则库的链接顺序也很重要。通常，如果库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

再说一遍，顺序很重要！

班级成员：

纯虚拟析构函数需要实现。

声明析构函数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允许在类内初始化所有静态常量数据成员。