防止递归 C #include

Question

我大致了解 #include 对 C 预处理器所做的规则，但我并不完全理解它。现在，我有两个头文件，Move.h 和 Board.h，它们都 typedef 各自的类型（Move 和 Board）。在两个头文件中，我需要引用另一个头文件中定义的类型。

现在我在 Board.h 中有#include“Move.h”，在 Move.h 中有#include“Board.h”。当我编译时，gcc 翻转并给我一个很长的（看起来像无限递归的）错误消息，在 Move.h 和 Board.h 之间翻转。

如何包含这些文件，以便我不会无限期地递归包含？

Answer 1

您需要查看前向声明，您已经创建了包含的无限循环，前向声明是正确的解决方案。

下面是一个例子：

Move.h

#ifndef MOVE_H_
#define MOVE_H_

struct board; /* forward declaration */
struct move {
    struct board *m_board; /* note it's a pointer so the compiler doesn't 
                            * need the full definition of struct board yet... 
                            * make sure you set it to something!*/
};
#endif

Board.h

#ifndef BOARD_H_
#define BOARD_H_

#include "Move.h"
struct board {
    struct move m_move; /* one of the two can be a full definition */
};
#endif

main.c

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

注意：每当你创建一个“Board”时，你都需要做这样的事情（有几种方法，这里是一个例子）：

struct board *b = malloc(sizeof(struct board));
b->m_move.m_board = b; /* make the move's board point 
                        * to the board it's associated with */

Answer 2

包括警卫将是解决此问题的一部分。

维基百科的示例：

#ifndef GRANDFATHER_H
#define GRANDFATHER_H

struct foo {
    int member;
};

#endif

http://en.wikipedia.org/wiki/Include_guard

另一部分正如其他几个人所指出的那样，这是前向引用。 (http://en.wikipedia.org/wiki/Forward_Reference)

您可以部分声明一个另一个结构之上的结构如下：

#ifndef GRANDFATHER_H
#define GRANDFATHER_H

struct bar;
struct foo {
    int member;
};

#endif

Answer 3

像这样：

//Board.h
#ifndef BOARD_H
#define BOARD_H
strunct move_t; //forward declaration
typedef struct move_t Move;
//...
#endif //BOARD_H

//Move.h
#ifndef MOVE_H
#define MOVE_H
#include "Move.h"
typedef struct board_t Board;
//...
#endif //MOVE_H

这样 Board.h 可以在不依赖 move.h 的情况下编译，并且您可以包含 move 中的 board.h .h 使其内容在那里可用。

Answer 4

首先，您的 .h 文件中似乎缺少 includeguards ，所以你递归地包含它们。那很糟糕。

其次，您可以进行前瞻性声明。在 Move.h 中：

/* Include guard to make sure your header files are idempotent */
#ifndef H_MOVE_
#define H_MOVE_

#include "Board.h"

/* Now you can use struct Board */
struct Move { struct Board *board; };

#endif

在 Board.h 中：

#ifndef H_BOARD_
#define H_BOARD_

struct Move; /* Forward declaration.  YOu can use a pointer to
                struct Move from now on, but the type itself is incomplete,
                so you can't declare an object of the type itself. */
struct Board { struct Move *move; }; /* OK: since move is a pointer */

#endif

请注意，如果需要声明 struct Move 和 struct Board如果两个文件中都存在对象（而不是指向其中之一的指针），则此方法将不起作用。这是因为在解析其中一个文件时，其中一种类型是不完整类型（上例中的struct Move）。

因此，如果您需要使用这两个文件中的类型，则必须分离出类型定义：具有定义 struct Move 和 struct Board 的头文件，以及没有别的（就像我上面的例子一样），然后使用另一个引用 struct Move 和 struct Board 的头文件。

当然，您不能让 struct Move 包含 struct Board 并且 struct Board 包含 struct Move同时，这将是无限递归，并且结构大小也将是无限的！

Answer 5

您首先需要拥有其中之一。在其中之一中进行前向声明，并将该声明作为例如

    #ifndef move
    struct move;
    #endif

board.h 文件的一部分。

并且

    #ifndef board
    struct board;
    #endif

可以是 move.h 文件的一部分，

然后您可以按任一顺序添加它们。

编辑
正如评论中指出的那样...我假设对板结构使用 typedef 构造如下，

   typedef struct {…} board;

因为我从未见过有人在没有 typedef 的情况下使用 C 中的结构我做了这个假设...也许事情已经改变了自从我上次用 C 编写代码以来（哎呀......那是 15 年前的事了）

Answer 6

循环依赖是一件令人头疼的事，应该尽可能消除。除了到目前为止给出的前向声明建议（Alok 的就是最好的例子）之外，我还想提出另一个建议：通过引入第三种类型（将其称为 BoardMoveAssoc 进行说明）来打破 Board 和 Move 之间的相互依赖；我相信你可以想出一个不那么糟糕的名字）：

#ifndef H_BOARD_MOVE_ASSOC
#define H_BOARD_MOVE_ASSOC

#include "Move.h"
#include "Board.h"

struct BoardMoveAssoc {
    Move m;
    Board b;
};

...
#endif

在这个方案下，Board 和 Move 不需要互相了解任何信息；两者之间的任何关联均由 BoardMoveAssoc 类型管理。确切的结构取决于 Move 和 Board 的关联方式；例如，如果多个动作映射到单个棋盘，则结构可能看起来更像

 struct BoardMoveAssoc {
     Move m[NUM_MOVES] // or Move *m;
     Board b;
 };

这样，您不必担心前向声明或不完整的类型。您正在将第三种类型引入其中，但我相信这会更容易理解和维护。

Answer 7

来自 K&R C 编程语言（我的副本中的第 91 页“条件包含”），为您做了一些调整：

#if !defined (BOARD_H)
#define BOARD_H

/* contents of board.h go here */

#endif

对于 Move.h 也是如此

，一旦包含一次标头，就不会包含它再次，因为已经为预处理器定义了“BOARD_H”名称。