由于我找不到这个问题的任何完整的（在我看来）重复，我将写一个（希望）权威且完整的答案。
什么是单一定义规则以及我为什么要关心
单一定义规则（通常称为 ODR）是一种规则，它规定（简化）程序中使用的任何实体（非正式术语）都应该定义一次，并且只能定义一次。多次定义的实体通常会导致编译或链接器错误，但有时编译器可能无法检测到并导致非常难以跟踪的错误。
我不打算正式定义entity这里，但我们可以将其视为函数、变量或类。在进一步讨论之前，我们应该非常清楚地了解两者之间的区别定义 and 宣言在C++中，虽然禁止双重定义，但双重声明通常是不可避免的。
定义与声明
代码中使用的每个实体都应该是declared在给定的翻译单元中（翻译单元通常是一个cpp源文件以及其中包含的所有头文件，直接或间接通过其他头文件）。实体的声明方式因实体本身而异。请参阅下文了解如何声明不同类型的实体。实体通常在头文件中声明。由于大多数复杂的应用程序中都包含多个翻译单元（多个 cpp 文件），并且不同的 cpp 文件通常包含相同的标头，因此应用程序可能对所使用的许多实体有多个声明。正如我上面所说，这不是问题。
应用程序中使用的每个实体都必须是defined一次且仅一次。术语“应用程序”在这里使用得有点宽松 - 例如，库（静态和动态）可以在其中保留未定义的实体（此时通常称为符号），并且链接以使用动态库的可执行文件可以还有一个未定义的符号。相反，我指的是应用程序是终极运行的某物，在所有库都已静态或动态链接到其中并解析符号之后。
还值得注意的是，每个定义也都充当声明，这意味着，每当您定义某些内容时，您也在声明相同的事物。
与声明一样，定义实体的方式因实体类型而异。以下是如何根据实体的类型声明/定义 3 种基本类型的实体 - 变量、类和函数。
变量
变量使用以下结构声明：
extern int x;
这声明了一个变量x。它没有定义它！下面的代码将被编译正常，但尝试在没有任何其他输入文件的情况下链接它（例如，使用g++ main.cpp) 将由于未定义的符号而产生链接时错误：
extern int x;
int main() {
return x;
}
下面这段代码defines变量 x：
int x;
如果将这一行放入文件 x.cpp 中，并且该文件与上面的 main.cpp 一起编译/链接g++ x.cpp main.cpp -o test它可以毫无问题地编译和链接。您甚至可以运行生成的可执行文件，如果您要在运行可执行文件后检查退出代码，您会注意到它是 0。（因为全局变量 x 将默认初始化为 0）。
功能
函数是通过提供其原型来声明的。典型的函数声明如下所示：
double foo(int x, double y);
该构造声明了一个函数foo，返回double并接受两个参数 - 一个类型int，另一种类型double。该声明可以出现多次。
以下代码defines上面提到的foo:
void foo(int x, double y) {
return x * y;
}
This 定义在整个应用程序中只能出现一次。
与变量定义相比，函数定义还有一个额外的特点。如果上面的定义foo被放入头文件中foo.h，这又将包含在两个 cpp 文件中1.cpp and 2.cpp，它们被编译/链接在一起g++ 1.cpp 2.cpp -o test你会遇到链接器错误，说foo()被定义了两次。这可以通过使用以下形式来防止foo宣言：
inline void foo(int x, double y) {
return x * y;
}
Note inline那里。它告诉编译器的是foo可以被多个.cpp文件包含，并且这个包含不应该产生链接器错误。编译器有多种选择来实现这一点，但可以依靠它来完成它的工作。请注意，在同一个翻译单元中两次使用此定义仍然会出现错误！例如，以下代码将产生编译器错误
inline void foo() { }
inline void foo() { }
值得注意的是，类中定义的任何类方法都是隐式内联的，例如：
class A {
public:
int foo() { return 42; }
};
这里定义了 A::foo()inline.
Classess
类通过以下构造声明：
class X;
以上声明declaresX 类（此时 X 被正式称为不完整类型），以便当不需要有关其内容的信息（例如其大小或其成员）时可以使用它。例如：
X* p; // OK - no information about class X is actually required to define a pointer to it
p->y = 42; // Error - compiler has no idea if X has any member named `y`
void foo(X x); // OK - compiler does not need to generated any code for this
void foo(X x) { } // Error - compiler needs to know the size of X to generate code for foo to properly read it's argument
void bar(X* x) { } // OK - compiler needs not to know specifics of X for this
类的定义是众所周知的，并且遵循以下结构：
class X {
public:
int y;
};
这使得类 X 被定义，现在它可以在任何上下文中使用。重要的注意事项 - 类定义对于每个翻译单元必须是唯一的，但不必对于每个应用程序都是唯一的。也就是说，每个翻译单元只能定义一次 X，但它可以在链接在一起的多个文件中使用。
如何正确遵守 ODR 规则
每当在生成的应用程序中多次定义同一实体时，即所谓的ODR 违规发生了。大多数时候，链接器会发现违规行为并会抱怨。但是，在某些情况下，ODR 违规不会破坏链接，而是会导致错误。例如，当定义全局变量 X 的同一个 .cpp 文件被放入应用程序和动态库中时，可能会发生这种情况，该文件是按需加载的（使用dlopen）。 （你确实花了几天时间试图追踪因此而发生的错误。）
ODR 违规的更常见原因是：
同一实体在同一范围内的同一文件中定义两次
int x;
int x; // ODR violation
void foo() {
int x;
} // No ODR violation, foo::x is different from x in the global scope
预防: 不要这样做。
同一个实体在应该声明的时候被定义了两次
(in x.h)
int x;
(in 1.cpp)
#include <x.h>
void set_x(int y) {
x = y;
}
(in 2.cpp)
#include <x.h>
int get_x() {
return x;
}
虽然上述代码的智慧充其量是值得怀疑的，但它在说明 ODR 规则方面起到了一定的作用。在上面的代码中，变量 x 应该在两个文件 1.cpp 和 2.cpp 之间共享，但编码不正确。相反，代码应该如下：
(in x.h)
extern int x; //declare x
(in x.xpp)
int x; // define x
// 1.cpp and 2.cpp remain the same
预防知道你在做什么。当您希望声明实体时声明它们，而不是定义它们。
如果在上面的示例中我们使用函数而不是变量，如下所示：
(in x.h)
int x_func() { return 42; }
我们会遇到一个可以通过两种方式解决的问题（如上所述）。我们可以使用inline函数，或者我们可以将定义移动到 cpp 文件中：
(in x.h)
int x_func();
(in x.cpp)
int x_func() { return 42; }
相同的头文件包含两次，导致同一个类定义两次这是一个有趣的事情。想象一下，您有以下代码：
(in a.h)
class A { };
(in main.cpp)
#include <a.h>
#include <a.h> // compilation error!
上面的代码很少出现，但很容易在中间两次包含相同的文件：
(in foo.h)
#include <a.h>
(in main.cpp)
#include <a.h>
#include <foo.h>
预防传统的解决方案是使用所谓的包括警卫，即一个特殊的预处理器定义，可以防止双重包含。在这方面，a.h应该重做如下：
(in a.h)
#ifndef INCLUDED_A_H
#define INCLUDED_A_H
class A { };
#endif
上面的代码将防止将 a.h 多次包含到同一翻译单元中，因为INCLUDED_A_H将在第一次包含后定义，并且会失败#ifndef关于所有后续的。
一些编译器公开了其他方法来控制包含，但迄今为止，包含防护仍然是在不同编译器之间统一执行此操作的方法。
