为什么 include Guard 不让循环 #include 起作用？

Question

我有三个类：GameEvents、Physics 和 GameObject。我为每个人都有标题。

• GameEvents 有一个 Physics 和一系列 GameObjects。
• Physics 有一个GameObjects 列表。

注意循环依赖。我试图实现 GameObject 能够访问或拥有 Physics 对象。

如果我只是在 GameObject 中#include "Physics.h"，我得到 我理解的错误C2111：'ClassXXX'：'class'类型重新定义。 这是我认为包含防护会有所帮助的地方，因此我在我的 Physics.h 中添加了一个包含防护，因为这是我想要包含两次的标头。

这就是它的样子

#ifndef PHYSICS_H
#define PHYSICS_H

#include "GameObject.h"
#include <list>

class Physics
{
private:
    double gravity;
    list<GameObject*> objects;
    list<GameObject*>::iterator i;
public:
    Physics(void);
    void ApplyPhysics(GameObject*);
    void UpdatePhysics(int);
    bool RectangleIntersect(SDL_Rect, SDL_Rect);
    Vector2X CheckCollisions(Vector2X, GameObject*);
};

#endif // PHYSICS_H

但是如果我在我的 GameObject.h 中 #include "Physics.h" 现在像这样：

#include "Texture2D.h"
#include "Vector2X.h"
#include <SDL.h>
#include "Physics.h"

class GameObject
{
private:
    SDL_Rect collisionBox;
public:
    Texture2D texture;
    Vector2X position;
    double gravityForce;
    int weight;
    bool isOnGround;
    GameObject(void);
    GameObject(Texture2D, Vector2X, int);
    void UpdateObject(int);
    void Draw(SDL_Surface*);
    void SetPosition(Vector2X);
    SDL_Rect GetCollisionBox();
};

我遇到多个问题，但不明白为什么会出现这些问题重新出现。 如果我不#include "Physics.h"我的代码运行得很好。

Answer 1

预处理器是一个程序，它接受您的程序，进行一些更改（例如包含文件（#include）、宏扩展（#define）以及基本上以 # 开头的所有内容）并给出“干净的” " 将结果发送给编译器。

当预处理器看到 #include 时，它的工作方式如下：

当您编写时：

#include "some_file"

some_file 的内容几乎从字面上复制粘贴到包含它的文件中。现在，如果您有：

a.h:
class A { int a; };

And：

b.h:
#include "a.h"
class B { int b; };

And：

main.cpp:
#include "a.h"
#include "b.h"

您将得到：

main.cpp:
class A { int a; };  // From #include "a.h"
class A { int a; };  // From #include "b.h"
class B { int b; };  // From #include "b.h"

现在您可以看到 A 是如何重新定义的。

当你编写守卫时，它们会变成这样：

a.h:
#ifndef A_H
#define A_H
class A { int a; };
#endif

b.h:
#ifndef B_H
#define B_H
#include "a.h"
class B { int b; };
#endif

现在让我们看看 main 中的 #include 如何扩展（这与前面的情况完全一样：复制粘贴）

main.cpp:
// From #include "a.h"
#ifndef A_H
#define A_H
class A { int a; };
#endif
// From #include "b.h"
#ifndef B_H
#define B_H
#ifndef A_H          // From
#define A_H          // #include "a.h"
class A { int a; };  // inside
#endif               // "b.h"
class B { int b; };
#endif

现在让我们跟随预处理器看看从中得出什么“真正的”代码。我会逐行：

// From #include "a.h"

评论。忽略！继续：

#ifndef A_H

A_H 定义了吗？不！然后继续：

#define A_H

好的，现在 A_H 已定义。继续：

class A { int a; };

这不是预处理器的事情，所以就不用管它了。继续：

#endif

前面的if到这里就结束了。继续：

// From #include "b.h"

评论。忽略！继续：

#ifndef B_H

B_H 定义了吗？不！然后继续：

#define B_H

好的，现在 B_H 已定义。继续：

#ifndef A_H          // From

A_H 定义了吗？是的！然后忽略，直到对应的#endif：

#define A_H          // #include "a.h"

忽略

class A { int a; };  // inside

忽略

#endif               // "b.h"

前面的if到这里就结束了。继续：

class B { int b; };

这不是预处理器的事情，所以就不用管它了。继续：

#endif

前面的if到这里就结束了。

也就是说，在预处理器处理完文件后，编译器会看到以下内容：

main.cpp
class A { int a; };
class B { int b; };

正如您所看到的，任何可以在同一个文件中获得 #included 两次的内容，无论是直接还是间接都需要被守护。由于 .h 文件总是很可能被包含两次，因此最好保护所有 .h 文件。

PS 请注意，您还有循环#include。想象一下预处理器将Physics.h的代码复制粘贴到GameObject.h中，它会看到有一个#include“GameObject.h”，这意味着将GameObject.h复制到其自身中。当你复制时，你再次得到#include "Pysics.h"并且你永远陷入了循环。编译器会阻止这种情况发生，但这意味着您的#include 已经完成了一半。

在说如何解决这个问题之前，您应该了解另一件事。

如果您有：

#include "b.h"

class A
{
    B b;
};

那么编译器需要了解有关 b 的所有信息，最重要的是，它有哪些变量等，以便它知道应该放置多少字节来代替 b > 在 A 中。

但是，如果您有：

class A
{
    B *b;
};

那么编译器实际上不需要了解有关 B 的任何信息（因为无论类型如何，指针都具有相同的大小）。关于 B 它唯一需要知道的是它存在！

因此，您执行称为“前向声明”的操作：

class B;  // This line just says B exists

class A
{
    B *b;
};

这与您在头文件中执行的许多其他操作非常相似，例如：

int function(int x);  // This is forward declaration

class A
{
public:
    void do_something(); // This is forward declaration
}

Answer 2

您在这里有循环引用：Physics.h 包含 GameObject.h，其中包含 Physics.h。您的类 Physics 使用 GameObject*（指针）类型，因此您无需在 Physics.h< 中包含 GameObject.h /code> 但只需使用前向声明 - 而不是

#include "GameObject.h" 

put

class GameObject;   

此外，在每个头文件中放置防护。

Answer 3

问题是您的 GameObject.h 没有防护，因此当您在 Physics.h 中 #include "GameObject.h" 时，它会得到当 GameObject.h 包含 Physics.h 时包含。

Answer 4

在所有 *.h 或 *.hh 头文件中添加包含防护（除非您有特定原因不这样做）。

要了解发生了什么，请尝试获取源代码的预处理形式。对于 GCC，它类似于 g++ -Wall -C -E yourcode.cc > yourcode.i （我不知道微软编译器是如何做到这一点的）。您还可以询问包含哪些文件，GCC 为 g++ -Wall -H -c yourcode.cc

Answer 5

首先你也需要在游戏对象上包含守卫，但这不是真正的问题

如果其他东西首先包含物理.h，物理.h包含游戏对象.h，你会得到这样的东西：

class GameObject {
...
};

#include physics.h

class Physics {
...
};

并且#include物理.h被丢弃，因为包含守卫，最终您会在声明物理之前声明游戏对象。

但如果您希望 GameObject 有一个指向物理的指针，那就是一个问题，因为对于 htat 物理必须首先声明。

要解决这个循环，您可以前向声明一个类，但前提是您仅在下面的声明中将其用作指针或引用，即：

#ifndef PHYSICS_H
#define PHYSICS_H

//  no need for this now #include "GameObject.h"

#include <list>

class GameObject;

class Physics
{
private:
    list<GameObject*> objects;
    list<GameObject*>::iterator i;
public:
    void ApplyPhysics(GameObject*);
    Vector2X CheckCollisions(Vector2X, GameObject*);
};

#endif // PHYSICS_H

Answer 6

在所有头文件中使用包含防护。由于您使用的是 Visual Studio，因此您可以使用 #pragma Once 作为所有标头中的第一个预处理器定义。

不过，我建议使用经典方法：

#ifndef CLASS_NAME_H_
#define CLASS_NAME_H_

// Header code here

#endif //CLASS_NAME_H_

第二次阅读 转发声明并应用它。

Answer 7

标头保护的目标是避免多次包含同一文件。
但目前C++中使用的头保护还可以改进。当前的守卫是：

#ifndef AAA_H
#define AAA_H

class AAA
{ /* ... */ };

#endif

我的新守卫建议是：

#ifndef AAA_H
#define AAA_H

class AAA
{ /* ... */ };

#else
class AAA;  // Forward declaration
#endif

这解决了当 AAA 类需要 BBB 类声明，而 BBB 类需要 AAA 类声明时出现的恼人问题，通常是因为从一个类到另一个类存在交叉指针：

// File AAA.h
#ifndef AAA_H
#define AAA_H

#include "BBB.h"

class AAA
{ 
  BBB *bbb;
/* ... */ 
};

#else
class AAA;  // Forward declaration
#endif

//+++++++++++++++++++++++++++++++++++++++

// File BBB.h
#ifndef BBB_H
#define BBB_H

#include "AAA.h"

class BBB
{ 
  AAA *aaa;
/* ... */ 
};

#else
class BBB;  // Forward declaration
#endif

我希望将其包含在自动从模板生成代码的 IDE 中。

Answer 8

" #pragma Once " ::: 与标头保护具有相同的目的，并且具有更短且不易出错的额外好处。

许多编译器支持使用 #pragma 指令的更简单的替代形式的标头保护：
“ #pragma 一次 ”
// 你的代码在这里

但是，#pragma Once 并不是 C++ 语言的官方部分，并且并非所有编译器都支持它（尽管大多数现代编译器都支持）。

出于兼容性目的，人们建议坚持使用传统的标头防护装置。它们不需要做更多的工作，并且保证所有兼容的编译器都支持它们。