C 头文件循环

Question

我有几个头文件，可以归结为：

tree.h:

#include "element.h"

typedef struct tree_
{
    struct *tree_ first_child;
    struct *tree_ next_sibling;
    int tag;
    element *obj;
    ....
} tree;

和 element.h:

#include "tree.h"

typedef struct element_
{
    tree *tree_parent;
    char *name;
    ...
} element;

问题是它们都互相引用，因此树需要包含元素，而元素需要包含树。

这是行不通的，因为要定义“树”结构，元素结构必须已知，而要定义元素结构，必须知道树结构。

如何解决这些类型的循环（我认为这可能与“前向声明”有关？）？

Answer 1

我认为这里的问题不是缺少包含保护，而是两个结构在定义中相互需要的事实。 所以这是一个类型定义 hann 和 Egg 的问题。

在 C 或 C++ 中解决这些问题的方法是对类型进行前向声明。 如果您告诉编译器该元素是某种结构，编译器就能够生成指向它的指针。

例如，

在tree.h 内：

// tell the compiler that element is a structure typedef:
typedef struct element_ element;

typedef struct tree_ tree;
struct tree_
{
    tree *first_child;
    tree *next_sibling;
    int tag;

    // now you can declare pointers to the structure.
    element *obj;
};

这样您就不必再在tree.h 内包含element.h 了。

您还应该在头文件周围放置包含保护。

Answer 2

这里重要的观察是元素不需要知道树的结构，因为它只保存指向树的指针。 对于树来说也是如此。 每个人都需要知道的是存在一个具有相关名称的类型，而不是其中的内容。

因此，在 tree.h 中，而不是：

#include "element.h"

do:

typedef struct element_ element;

这“声明”类型“element”和“struct element_”（表示它们存在），但不“定义”它们（表示它们是什么）。 存储指向 blah 的指针所需要做的就是声明 blah，而不是定义它。 仅当您想要遵循它（例如读取成员）时才需要定义。 “.c”文件中的代码需要执行此操作，但在本例中，您的标头不需要执行此操作。

有些人创建一个头文件，该文件前向声明头簇中的所有类型，然后每个头都包含该类型，而不是确定它真正需要哪些类型。 这既不是必要的，也不是完全愚蠢的。

关于包含警卫的答案是错误的 - 一般来说，它们是一个好主意，您应该阅读它们并为自己准备一些，但它们并不能特别解决您的问题。

Answer 3

正确的答案是使用包含防护，并使用前向声明。

Include Guards

/* begin foo.h */
#ifndef _FOO_H
#define _FOO_H

// Your code here

#endif
/* end foo.h */

Visual C++ 还支持#pragma Once。 它是一个非标准预处理器指令。 作为编译器可移植性的交换，您可以减少预处理器名称冲突的可能性并提高可读性。

前向声明

前向声明您的结构。 如果没有明确需要结构或类的成员，则可以在头文件的开头声明它们的存在。

struct tree;    /* element.h */
struct element; /* tree.h    */

Answer 4

了解前向声明。

IE。

// tree.h:
#ifndef TREE_H
#define TREE_H
struct element;
struct tree
{
    struct element *obj;
    ....
};

#endif

// element.h:
#ifndef ELEMENT_H
#define ELEMENT_H
struct tree;
struct element
{
    struct tree *tree_parent;
    ...
};
#endif

Answer 5

这些被称为“一次性标头”。 请参阅 http://developer .apple.com/DOCUMENTATION/DeveloperTools/gcc-4.0.1/cpp/Once_002dOnly-Headers.html#Once_002dOnly-Headers

Answer 6

包含防护很有用，但不能解决发布者的问题，即对两个数据结构的递归依赖。

这里的解决方案是将树和/或元素声明为指向头文件中结构的指针，因此您不需要包含 .h

类似的内容：

struct element_;
typedef struct element_ element;

在 tree.h 的顶部应该足以消除包含的需要element.h

使用这样的部分声明，您只能使用元素指针执行不需要编译器了解有关布局的任何信息的操作。

Answer 7

恕我直言，最好的方法是避免此类循环，因为它们是应该避免的物理耦合的标志。

例如（据我所知）“面向对象的设计启发式”目的是避免包含防护，因为它们仅屏蔽循环（物理）依赖性。

另一种方法是预先声明结构，如下所示：
<代码>

element.h:
struct tree_;
struct element_
  {
    struct tree_ *tree_parent;
    char *name;
  };


  树.h： 
  结构元素_； 
  结构树_ 
    { 
      结构树_*first_child; 
      结构树_* next_sibling; 
      int 标签； 
      结构元素_*obj； 
    }; 

Answer 8

前向声明是一种可以保证稍后定义的结构类型的方法。

Answer 9

我不喜欢前向声明，因为它们是多余的并且有错误。 如果您希望所有声明都位于同一位置，那么您应该使用包含和带有包含防护的头文件。

您应该将 include 视为复制粘贴，当 c 预处理器找到 #include 行时，会将 myheader.h 的整个内容放在找到 #include 行的同一位置。

好吧，如果您编写 include 保护，则 myheader.h 的代码将仅在找到第一个 #include 的地方粘贴一次。

如果您的程序使用多个目标文件进行编译并且问题仍然存在，那么您应该在目标文件之间使用前向声明（就像使用 extern），以便仅保留所有目标文件的类型声明（编译器混合同一个表中的所有声明，并且标识符必须是独一无二的）。

Answer 10

一个简单的解决方案是不使用单独的头文件。 毕竟，如果它们相互依赖，那么您永远不会只使用其中一个而不使用另一个，那么为什么要将它们分开呢？ 您可以拥有单独的 .c 文件，它们都使用相同的标头，但提供更集中的功能。

我知道这并不能回答如何正确使用所有奇特的东西的问题，但当我寻找类似问题的快速解决方案时，我发现它很有帮助。

Answer 11

这里的很多答案都提到了“包括守卫”和“前向声明”，但他们都没有真正意图解决OP当前面临的问题。 第三个“.h”文件绝对不是答案。 如果使用得当，“包含防护”可以打破“#include循环”并最终导致更清晰的项目结构。 如果您已经有两个头文件，为什么还要为 typedef 创建另一个头文件呢？ 你的头文件应该是这样的：

/* a.h - dependency of b.h */
#ifndef _A_H
#define _A_H

#include "b.h"

typedef struct a_p {
    b_t *b;
} a_t;

#endif // _A_H

/* b.h - dependency of a.h */
#ifndef _B_H
#define _B_H

typedef struct b_p b_t;

/** 
 * !!!
 * to avoid recursion, only include "a.h" 
 * when "a.h" isn't included before
 */
#ifndef _A_H
    #include "a.h"
    typedef struct b_p {
        a_t a;
    } b_t;
#endif

#endif // _B_H

要使用这两个头文件，你只需要 include 一个，即无条件包含另一个的头文件（在本例中，ah）。 但如果您愿意，您也可以包含“bh”。 但无论如何，它不会产生任何影响（由于前向声明）。

#include "a.h"

int main() {
    a_t aigh;

    return 0;
}

瞧！ 就是这个！ 没有额外的include什么都没有。 我们有他们！