由于我找不到任何完整(在我看来)这个问题的重复,我将写一个(希望)权威和完整的答案。
什么是一个定义规则,我为什么要关心
单一定义规则,通常称为 ODR,是一种规则,它规定(简化)程序中使用的任何实体(非正式术语)都应该定义一次,并且只定义一次。定义不止一次的实体通常会导致编译或链接器错误,但有时编译器可能无法检测到并导致非常难以跟踪的错误。
这里我不打算正式定义entity,但可以将其视为一个函数、变量或类。在进一步讨论之前,应该非常清楚地了解C++中definition和declaration之间的区别,因为虽然禁止双重定义,但双重声明通常是不可避免的。
定义与声明
代码中使用的每个实体都应该在给定的翻译单元中声明(翻译单元通常是一个 cpp 源文件以及其中包含的所有头文件,直接或间接通过其他头文件) .实体的声明方式因实体本身而异。请参阅下文,了解如何声明不同类型的实体。实体通常在头文件中声明。由于最复杂的应用程序中包含多个翻译单元(多个 cpp 文件),并且不同的 cpp 文件通常包含相同的标头,因此应用程序可能对使用的许多实体有多个声明。就像我上面说的,这不是问题。
应用程序中使用的每个实体都必须定义一次且仅一次。术语“应用程序”在这里使用得有点松散 - 例如,库(静态和动态)可以在其中包含未定义的实体(此时通常称为符号),并且链接到使用动态库的可执行文件可以还有一个未定义的符号。相反,我指的是应用程序是一个终极运行的东西,毕竟所有库都已静态或动态链接到其中,并解析了符号。
还值得注意的是,每个定义也都用作声明,这意味着,无论何时定义某些内容,您也声明了相同的内容。
与声明一样,定义实体的方式因实体类型而异。以下是如何根据实体类型声明/定义 3 种基本类型的实体 - 变量、类和函数。
变量
使用以下构造声明变量:
extern int x;
这声明了一个变量 x。它没有定义它!下面的一段代码可以编译成功,但是如果尝试在没有任何其他输入文件的情况下链接它(例如,使用g++ main.cpp),则会由于未定义的符号而产生链接时错误:
extern int x;
int main() {
return x;
}
以下代码定义变量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类型。该声明可以出现多次。
下面的代码定义上面提到的foo:
void foo(int x, double y) {
return x * y;
}
这个定义在整个应用程序中只能出现一次。
函数定义对变量定义有一个额外的怪癖。如果将上述foo 的定义放入头文件foo.h 中,该文件又将包含在两个cpp 文件1.cpp 和2.cpp 中,它们与g++ 1.cpp 2.cpp -o test 一起编译/链接,您将拥有一个链接器错误,说foo() 被定义了两次。这可以通过使用以下形式的foo 声明来防止:
inline void foo(int x, double y) {
return x * y;
}
请注意inline。它告诉编译器的是foo 可以包含在多个 .cpp 文件中,并且这种包含不应产生链接器错误。编译器对于如何实现这一点有多种选择,但可以依靠它来完成它的工作。请注意,在同一个翻译单元中有两次此定义仍然是错误的!例如下面的代码会产生编译错误
inline void foo() { }
inline void foo() { }
值得注意的是,类中定义的任何类方法都是隐式内联的,例如:
class A {
public:
int foo() { return 42; }
};
这里 A::foo() 定义为inline。
类
类由以下构造声明:
class X;
上面的声明声明类X(并且此时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>
预防 对此的传统解决方案是使用所谓的include guards,即一种特殊的预处理器定义,可以防止双重包含。对此,a.h 应重做如下:
(in a.h)
#ifndef INCLUDED_A_H
#define INCLUDED_A_H
class A { };
#endif
上面的代码将阻止 a.h 多次包含在同一个翻译单元中,因为 INCLUDED_A_H 将在第一次包含后被定义,并且在所有后续的 #ifndef 中都将失败。
一些编译器公开了其他控制包含的方法,但迄今为止,包含保护仍然是在不同编译器之间统一执行此操作的方式。