c++ - 多定义错误C++

Question

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

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

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

common_utility.h

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

为A类编写代码
A类

class A
{
// Contains class A Declarations.

};

A类

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

// class A Method definition

B类代码
我正在使用B类中的A类。

B类

 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

我收到以下错误。

In function ifFileExist()': classB.cpp:(.text+0x0): multiple
definition ofifFileExist()' /tmp/ccHkDT11.o:classA.cpp:(.text+0x2b6e): first defined here

因此，我将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

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

Answer 1

由于我找不到该问题的完整(我认为)重复副本，因此我将写一个(希望)权威且完整的答案。
什么是一个定义规则，为什么我要关心
一个定义规则(通常称为ODR)是一条规则，指出(简化)程序中使用的任何实体(非正式术语)都应定义一次，并且只能定义一次。多次定义的实体通常会导致编译或链接器错误，但是有时编译器可能会忽略它们，并导致非常难以跟踪的错误。
我不会在这里正式定义实体，但可以将其视为函数，变量或类。在继续之前，应该非常清楚地了解C++中的定义和声明之间的区别，因为尽管禁止了双重定义，但通常不可避免地需要双重声明。
定义与声明
在代码中使用的每个实体都应在给定的翻译单元中用声明为(翻译单元通常是cpp源文件以及其中包含的所有头文件，直接或通过其他头文件间接)。实体的声明方式因实体本身而异。参见下文，了解如何声明不同类型的实体。实体通常在头文件中声明。由于大多数复杂的应用程序中都包含一个以上的转换单元(一个以上的cpp文件)，并且不同的cpp文件通常包含相同的 header ，因此一个应用程序可能会为使用的许多实体提供多个声明。就像我上面说的那样，这不是问题。
应用程序中使用的每个实体都必须被定义一次，并且只能一次。 “应用程序”一词在这里使用得比较宽松-例如，库(静态和动态)中可以包含未定义的实体(此时通常称为符号)，而链接为使用动态库的可执行文件可以也有 undefined symbol 。相反，我指的是在所有库都已静态或动态链接到应用程序并解析了符号之后，应用程序才是最终运行的东西。
还值得注意的是，每个定义也都充当声明，这意味着，每当定义某些内容时，您也就声明了同一件事。
与声明一样，定义实体的方法因实体类型而异。这是一种可以根据实体的类型声明/定义3种基本类型的实体的方法-变量，类和函数。
变数
使用以下构造声明变量:

extern int x;

这声明了变量x。它没有定义!下面的代码将被编译为OK，但是由于没有定义符号而试图在没有任何其他输入文件的情况下链接它(例如，使用 g++ main.cpp)将产生链接时错误:

extern int x;
int main() {
    return x;
}

以下代码段 定义了变量x:

int x;

如果将这一行放入文件x.cpp中，并且此文件与 g++ x.cpp main.cpp -o test从上面与main.cpp一起编译/链接在一起，则它将毫无问题地进行编译和链接。您甚至可以运行生成的可执行文件，如果要在运行可执行文件后检查退出代码，您会发现它为0。(因为全局变量x将默认初始化为0)。
功能
通过提供其原型(prototype)来声明函数。典型的函数声明如下所示:

double foo(int x, double y);

此结构声明一个函数 foo，返回 double并接受两个参数-一个参数为 int类型，另一个参数为 double类型。该声明可以出现多次。
以下代码 定义了上面提到的foo的:

void foo(int x, double y) {
    return x * y;
}

此 定义只能在整个应用程序中出现一次。
函数定义对变量定义有一个额外的怪癖。如果将 foo的上述定义放到头文件 foo.h中，而头文件 1.cpp又将包含在两个cpp文件 2.cpp和 g++ 1.cpp 2.cpp -o test中，它们与 foo()一起编译/链接在一起，则将出现链接器错误，说 foo被定义了两次。使用以下形式的 inline声明可以防止这种情况:

inline void foo(int x, double y) {
    return x * y;
}

注意那里的 foo。它告诉编译器的是 inline可以包含在多个.cpp文件中，而这种包含的 应该不会产生链接器错误。编译器有几种实现方法，但可以依靠它来完成任务。请注意，在同一翻译单元中两次定义都将是一个错误!例如，以下代码将产生编译器错误

inline void foo() { }
inline void foo() { }

值得注意的是，该类中定义的任何类方法都是隐式内联的，例如:

class A {
public:
    int foo() { return 42; }
};

此处A::foo()定义为 dlopen。
类(class)
通过以下构造声明类:

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，现在可以在任何上下文中使用它。重要说明-类定义在每个trannlation单元中必须唯一，但在每个应用程序中不必唯一。也就是说，每个转换单元只能定义一次X，但是它可以在链接在一起的多个文件中使用。
如何正确遵守ODR规则
每当在结果应用程序中多次定义同一实体时，就会发生所谓的 ODR违例。在大多数情况下，链接器会看到违规行为并会提示。但是，在某些情况下，违反ODR的操作不会中断链接，而是会导致错误。例如，当将定义全局变量X的相同.cpp文件放入应用程序库和动态库中时，可能会发生这种情况，并按需加载(使用 inline)。 (您确实花了几天的时间来尝试跟踪由于此而发生的错误。)
违反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

预防
知道你在做什么。在声明实体时声明它们，不要定义它们。
如果在上面的示例中，我们将使用function而不是变量，如下所示:

(in x.h)
int x_func() { return 42; }

我们将有一个可以通过两种方式解决的问题(如上所述)。我们可以使用 INCLUDED_A_H函数，也可以将定义移至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多次包含在同一个翻译单元中，因为 #ifndef将在首次包含之后定义，并且在所有后续的ojit_code上都会失败。
一些编译器提供了其他控制包含的方法，但是到目前为止，包括防护仍然是在不同的编译器之间统一地执行此操作的方法。