在两个不同的头文件中的两个结构中包含循环依赖是错误的吗？

Question

我有一个非常大的程序没有编译，我怀疑它与结构之间的循环依赖有关。当我像下面这样编码时，它不会编译

foo.h

#ifndef FOO
#define FOO

#include "bar.h"


typedef struct _foo Foo;

struct _foo{
  Bar *bar;
}

#endif

bar.h

#ifndef BAR
#define BAR

#include "foo.h"

typedef struct _bar Bar;

struct _bar{
  Foo *foo;
}

#endif

但如果我完全搞砸了我的设计并创建了一个 common.h 文件，并将所有结构声明放入其中，它似乎可以工作。

common.h

#ifndef COMMON
#define COMMON

typedef struct _foo Foo;
typedef struct _bar Bar;

#endif

foo.h

#ifndef FOO
#define FOO

#include "common.h"
#include "bar.h"

struct _foo{
  Bar *bar;
}

#endif

bar.h

#ifndef BAR
#define BAR

#include "common.h"
#include "foo.h"

struct _bar{
  Foo *foo;
}

#endif

这似乎是非常糟糕的设计。此外，我认为标头保护旨在防止由循环包含引起的问题。我应该使用 common.h 方法，还是我做错了什么导致我的第一个解决方案失败？

Answer 1

不同文件中的相互递归结构没有问题。

这里的主要问题是循环包含不起作用。然而，解决这个问题很容易，因为两个标题都不能包含另一个。

如果你跳过typedef，你可以这样做：

// In a.h
struct a {
    struct b *ptr;
};

和

// In b.h
struct b {
    struct a *ptr;
};

或者

如果你想使用 typedef，你只需要在结构定义中跳过使用它。

// In a.h
struct a {
    // Have to use 'struct b' instead of 'b' because we can't guarantee
    // that the typedef for b is visible yet.
    struct b *ptr;
};
typedef struct a a;

和

// In b.h
struct b {
    // Have to use 'struct a' instead of 'a' because we can't guarantee
    // that the typedef for a is visible yet.
    struct a *ptr;
};
typedef struct b b;

Answer 2

使用以下 C 文件：

#include <stdio.h>
#include "foo.h"
#include "bar.h"

int main()
{
    Foo f = { NULL };
    Bar b = { NULL };
    printf("hello\n");
    return 0;
}

预处理器输出以下内容（不包括stdio.h的内容）：

# 2 "x1.c" 2
# 1 "foo.h" 1



# 1 "bar.h" 1



# 1 "foo.h" 1
# 5 "bar.h" 2

typedef struct _bar Bar;

struct _bar{
  Foo *foo;
}
# 5 "foo.h" 2
typedef struct _foo Foo;

struct _foo{
  Bar *bar;
}
# 3 "x1.c" 2


int main()
{
    Foo f = { ((void *)0) };
    Bar b = { ((void *)0) };
    printf("hello\n");
    return 0;
}

请注意，Foo 的 typedef 在被引用之后出现。这就是导致错误的原因。因为Foo 和Bar 相互依赖，所以最好将两者定义在同一个标​​头中，并且每个都先定义typedef。

Answer 3

每种类型都必须在使用前声明（但不一定定义）。这不会发生在您的第一种方法中。假设您要在主程序中包含bar.h。因为foo.h 包含在其中，并且由于您的标头保护结构，编译器会生成如下内容：

typedef struct _foo Foo;

struct _foo{
  Bar *bar;
}

typedef struct _bar Bar;

struct _bar{
  Foo *foo;
}

int main( int argc, char* argv[] ){
  //Program stuff
}

然后它会尝试从上到下编译。问题是它达到了定义

struct _foo{
  Bar *bar;
}

不知道该怎么做，因为编译器还没有看到Bar。

解决方案是使用前向声明 向编译器声明将有一个名为struct _bar 的类型，并且您保证稍后会定义此类型。例如，下面的编译就好了：

struct _bar; //Forward declaration of 'struct _bar'

struct _foo{ //Definition of 'struct _foo'
  struct _bar myBar;
}

struct _bar{ //Definition of 'struct _bar'
  struct _foo myFoo;
}

特别是在您的情况下，将所有前向声明放在专用头文件中，或者仅在每个头文件中前向声明每种类型都是一种很好的形式。例如：

bar.h

#ifndef BAR
#define BAR

struct _foo; //Defined in foo.h, circular dependency

struct _bar{
  struct _foo *foo;
}

#endif

foo.h

#ifndef FOO
#define FOO

struct _bar; //Defined in bar.h, circular dependency

struct _foo{
  struct _bar *bar;
}

#endif

正如在 cmets 中所指出的，标头保护不会为您“解决”这个问题——它们只是防止每个头文件被多次包含（这通常会导致重新定义错误）。正确的解决方案是确保编译器在您使用它之前知道您将要使用的每种类型。

Answer 4

我看到一个明显的问题——在foo.h 的标头保护中，您使用结构的名称作为保护。这应该是宏的全部大写。我猜这是某种 IDE 自动替换，它意外地溜进了你的代码？

您遇到的问题可能不止于此，但仍然如此。 =]