为什么我的 include 保护不能防止递归包含和多个符号定义？

1. 在解析 main.cpp时，预处理器将满足指令 #include "a.h"。该指令告诉预处理器处理头文件 a.h，取得该处理的结果，并用该结果替换字符串 #include "a.h";
2. 在处理 a.h时，预处理器将满足指令 #include "b.h"，同样的机制适用于: 预处理器将处理头文件 b.h，取其处理结果，并用该结果替换 #include指令;
3. 在处理 b.h时，指令 #include "a.h"将告诉预处理器处理 a.h并用结果替换该指令;
4. 预处理器将再次开始解析 a.h，再次满足 #include "b.h"指令，这将建立一个潜在的无限递归过程。当达到关键嵌套级别时，编译器将报告错误。

然而，当 include 警卫出现 时，在步骤4中不会设置无限递归。让我们看看为什么:

1. (和以前一样)解析 main.cpp时，预处理器将满足指令 #include "a.h"。这告诉预处理器处理头文件 a.h，取得该处理的结果，并用该结果替换字符串 #include "a.h";
2. 在处理 a.h时，预处理器将满足指令 #ifndef A_H。由于宏 A_H尚未定义，它将继续处理以下文本。后续指令(#defines A_H)定义宏 A_H。然后，预处理器将满足指令 #include "b.h": 预处理器现在处理头文件 b.h，取其处理结果，并用该结果替换 #include指令;
3. 在处理 b.h时，预处理器将满足指令 #ifndef B_H。由于宏 B_H尚未定义，它将继续处理以下文本。后续指令(#defines B_H)定义宏 B_H。然后，指令 #include "a.h"告诉预处理器对 a.h进行预处理，并用预处理 a.h的结果替换 b.h中的 #include指令;
4. 编译器将再次开始预处理 a.h，并再次满足 #ifndef A_H指令。但是，在以前的预处理过程中，定义了宏 A_H。因此，这次编译器将跳过以下文本，直到找到匹配的 #endif指令，并且该处理的输出是空字符串(当然，假设没有遵循 #endif指令)。因此，预处理器将用空字符串替换 b.h中的 #include "a.h"指令，并将追踪执行，直到它替换 main.cpp中的原始 #include指令。

然而，它们不能在相互包含的文件中帮助 类定义之间的依赖关系:

//================================================
// a.h


#ifndef A_H
#define A_H


#include "b.h"


struct A
{
};


#endif // A_H


//================================================
// b.h


#ifndef B_H
#define B_H


#include "a.h"


struct B
{
A* pA;
};


#endif // B_H


//================================================
// main.cpp
//
// Good luck getting this to compile...


#include "a.h"
int main()
{
...
}

鉴于上述标题，main.cpp将无法编译。

为什么会这样？

要了解发生了什么，只需再次执行步骤1-4即可。

很容易看出，前三个步骤和第四个步骤中的大部分都没有受到这种变化的影响(只要通读一下就会明白)。然而，在步骤4的末尾发生了一些不同的事情: 在用空字符串替换了 b.h中的 #include "a.h"指令之后，预处理器将开始解析 b.h的内容，特别是 B的定义。不幸的是，B的定义提到了类 A，它在包含保护的 因为之前从来没有被满足过！

声明一个之前没有声明过的类型的成员变量当然是一个错误，编译器会礼貌地指出这一点。

我需要做什么来解决我的问题？

你需要 前进声明。

实际上，定义类 B并不需要类 A的 定义，因为 指针到 A被声明为成员变量，而不是 A类型的对象。因为指针的大小是固定的，所以编译器不需要知道 A的确切布局，也不需要计算它的大小来正确定义类 B。因此，对于 b.h中的 B0类 A，并让编译器知道它的存在就足够了:

//================================================
// b.h


#ifndef B_H
#define B_H


// Forward declaration of A: no need to #include "a.h"
struct A;


struct B
{
A* pA;
};


#endif // B_H

你的 main.cpp现在肯定能编译了。一些注意事项:

1. 在 b.h中用一个前向声明代替 #include指令不仅打破了相互包含，还有效地表达了 B对 A的依赖: 尽可能使用转发声明/实际上也被认为是 b.h1，因为它有助于避免不必要的包含，从而减少整体编译时间。然而，在消除相互包含之后，main.cpp将不得不修改为 #include a.h和 b.h(如果完全需要后者的话) ，因为 b.h不再是通过 a.h间接的 #included;
2. 虽然类 A的前向声明足以让编译器声明指向该类的指针(或者在任何其他可以接受不完全类型的上下文中使用它) ，但是解引用指向 A的指针(例如调用成员函数)或计算其大小是对不完全类型的 非法的操作: 如果需要，编译器需要获得完整的 A定义，这意味着定义它的头文件必须包含在内。这就是为什么类定义和它们的成员函数的实现通常被分割成一个头文件和该类的一个实现文件(类 模板是这个规则的例外) : 实现文件，它们从来没有被项目中的其他文件 #included，可以安全地 #include所有必要的头使定义可见。另一方面，头文件不会使用 #include其他头文件 除非，它们确实需要这样做(例如，使 基础课程的定义可见) ，并且只要可能/实际可行，就会使用正向声明。

第二个问题:

为什么不包括防止 多重定义的警卫？

他们很强大。

//================================================
// source1.cpp
//
// Good luck getting this to compile...


#include "header.h"
#include "header.h"


int main()
{
...
}