【问题标题】:multiple definition error c++多定义错误c ++
【发布时间】:2016-04-09 10:41:15
【问题描述】:

我的“Headers.h”文件包含基本的 c++ 头文件

#include <iostream>
#include <cstring>
// and many header files.

为文件存在检查编写了一个函数定义并将其保存在 'common_utility.h' - ifFileExist()

common_utility.h

bool ifFileExist()
{
   // ... My code
}

为 A 类编写代码 类A.h

class A
{
// Contains class A Declarations.

};

classA.cpp

// Contains
#include "Headers.h"
#include "common_utility.h"
#include "classA.h"

// class A Method definition

为 B 类编写代码 我在 B 类中使用 A 类。

classB.h

 class B
    {
// Contains class A Declarations.
}

classB.cpp

// Contains
#include "Headers.h"
#include "common_utility.h"
#include "classA.h"
#include "classB.h"

// class B Method definition
// calling the function ifFileExist() in class B also.

为主程序编写代码 main.cpp

// Contains
#include "Headers.h"
#include "common_utility.h"
#include "classA.h"
#include "classB.h"

// I am using class A and Class B in main program
// calling the function ifFileExist() in Main program also.

当我将整个程序编译为

g++ -std=c++0x classA.cpp classB.cpp main.cpp -o main

我收到以下错误。

在函数ifFileExist()': classB.cpp:(.text+0x0): multiple definition ofifFileExist()' /tmp/ccHkDT11.o:classA.cpp:(.text+0x2b6e): 这里先定义

所以我将 Headers.h 中的 ifFileExist() 函数取消为 extern。

extern bool ifFileExist();

但我仍然遇到同样的错误。

我在每个 .cpp 文件中都包含“Headers.h”。该文件包含基本的 c++ 库。但是我没有得到该头文件的任何多重定义错误。 但仅在我自己的函数中,我收到错误“多重定义”。

我想在需要时使用“common_utility.h”文件。如果我不需要在我的主程序中使用 common_utility 函数,我就不应该包含它。

我希望我的程序在以下所有情况下都能运行。

g++ -std=c++0x classA.cpp main.cpp -o main
g++ -std=c++0x classB.cpp> main.cpp -o main
g++ -std=c++0x classA.cpp classB.cpp main.cpp -o main

在任何情况下我都不应该出现多重定义错误。我现在该怎么办?

【问题讨论】:

  • 为 ODR 寻找重复的问题,但找不到任何好的问题。我确定它存在,可能有人能找到它吗?
  • 由于没找到好的副本,我自己写点东西。
  • 你在头文件中使用了包含保护吗?

标签: c++ header-files multiple-definition-error


【解决方案1】:

由于我找不到任何完整(在我看来)这个问题的重复,我将写一个(希望)权威和完整的答案。

什么是一个定义规则,我为什么要关心

单一定义规则,通常称为 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 中都将失败。

一些编译器公开了其他控制包含的方法,但迄今为止,包含保护仍然是在不同编译器之间统一执行此操作的方式。

【讨论】:

  • 在包含在多个源文件中的头文件中定义的函数的情况下:包含保护是否有助于防止 ODR 违规?还是我必须在函数事件中使用inline,尽管我在头文件中包含了保护?
  • @zardosht,是的,你必须使用inline - 包含保护只防止在same 翻译单元(cpp 文件)中多次包含。
  • 我看到人们在头文件中定义常量,比如const double SOME_CONSTANT = 2.5;。这怎么不会导致多重定义问题? (我非常认为这与const 关键字有关。但是你能解释一下下面的原因吗?)
  • @zardosht const 定义是隐式内联的(具有内部链接),除非它们之前已声明为 extern。有关详细信息,请参阅en.cppreference.com/w/cpp/language/storage_duration。
【解决方案2】:

在实际编译源代码之前,编译单元是从 .cpp 文件生成的。这基本上意味着计算所有预处理器指令:所有#include 将被包含文件的内容替换,所有#define'd 值将替换为相应的表达式,所有#if 0 ... #endif 将被删除,等等。所以之后在您的情况下,这一步您将获得两条没有任何预处理器指令的 C++ 代码,它们都具有相同函数 bool ifFileExist() 的定义,这就是您收到此多重定义错误的原因。

快速的解决方案是将其标记为inline bool ifFileExist()。基本上你要求编译器用函数本身的内容替换所有相应的函数调用。

另一种方法是在 common_utility.h 中声明函数并将定义移动到 common_utility.cpp

【讨论】:

  • inline 关键字和实际内联仅是相切相关的。一个解释另一个是不正确的。编译器可以内联未声明的函数inline,或者无法内联这样声明的函数。这对程序语义没有影响。
  • Basically you ask compiler to replace all corresponding function calls with content of the function itself. - 这完全是错误的。关键字inline与函数内联无关。
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2011-07-19
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多