将耦合类拆分为单独的标头

Question

我正在尝试将以下两个类分开，以便每个类都可以在其自己的 Header 中定义：

---

#include <iostream>

class Boo;
class Foo
{
public:
    Foo(Boo *booPtr)
    :booPtr(booPtr){};
    virtual ~Foo(){};
    Boo *booPtr;
};

class Boo
{
public:
    Boo()
    :foo(this){};
    virtual ~Boo(){};
    Foo foo;
    int num = 32;
};

int main()
{
    Boo *boo = new Boo;
    std::cout << "booPtr : " << boo->foo.booPtr->num << '\n';
    delete boo;
}

结果：

booPtr : 32
Program ended with exit code: 0

---

这是我失败的分离尝试：

"Foo.hpp"

#ifndef Foo_hpp
#define Foo_hpp

#include <stdio.h>
#include "Boo.hpp"

class Foo
{
public:
    Foo(Boo *booPtr)
    :booPtr(booPtr){};
    virtual ~Foo(){};
    Boo *booPtr;
};

#endif /* Foo_hpp */

"Boo.hpp"

#ifndef Boo_hpp
#define Boo_hpp

#include <stdio.h>
#include "Foo.hpp"

class Boo
{
public:
    Boo()
    :foo(this){};
    virtual ~Boo(){};
    Foo foo; // Error : Field has incomplete type 'Boo'
    int num = 32;
};

#endif /* Boo_hpp */

"main.cpp"

#include <iostream>
#include "Foo.hpp"
#include "Boo.hpp"

int main()
{
    Boo *boo = new Boo;
    std::cout << "booPtr : " << boo->foo.booPtr->num << '\n';
    delete boo;
}

但我无法构建代码，因为它会生成以下错误：

Boo.hpp -> Foo foo; -> "字段的类型不完整 'Boo'"

如何修复我的代码？

Answer 1

您有一个文件包含另一个文件，反之亦然。这就形成了一个包容的循环。

意识到#include 宏除了用另一个文件替换它自己（即它的行）之外什么都不做。这很明显为什么您不能让文件 A 包含文件 B。

显而易见的解决方案是在 Foo 中提出 Boo 的前向声明：

#ifndef Foo_hpp
#define Foo_hpp

#include <stdio.h>
class Boo;

class Foo
{
public:
...

奇怪的是，你在分开之前就已经这样做了。

现在为您提供更多理论：从技术上讲，一个类是一种数据存储。它需要知道它的大小才能保留内存。因此，它需要知道它的成员的所有大小，只有在声明它们时才能知道。因此，一个类需要包含它作为成员的每个类的声明头。但是，指向对象的指针是不同的（引用也是如此）。指针始终采用相同的大小，即 32 位或 64 位，具体取决于您的平台（可能是 64 位，因为我们现在有 64 位平台）。因此，类不需要知道它指向的类，它为其指针成员保留的内存总是相同的大小。这就是为什么在这里可以使用前向声明（不涉及类大小）的原因。

Answer 2

虽然循环包含本身，假设正确的包含保护不是错误，但请记住它只是文本替换：

确保所有排列都是可行的并且具有相同的含义！

在您的情况下，将 "Boo.hpp" 的包含替换为您在合并源中出于某种原因使用的前向声明。

或者，你知道，干脆放弃拆分标题：
请记住，类不一定是适当的组织单位。

Answer 3

关于循环包含的附录，以 Foo.hpp 开头：

#ifndef FOO
#define FOO  // (!)

// now including BOO!
#ifndef BOO
#define BOO

// now including FOO  a g a i n
// as FOO  i s  already defined, all that remains is:
#ifndef FOO
#endif

class Boo { }; // now lacking definition of Foo...

#endif // BOO

class Foo { };

#endif // FOO (first one)

与 Boo.hpp 类似（您只需要预先声明 Foo，但没有，因为定义再次遵循之后......）。

如您所见，循环包含，提供适当的包含保护，不会导致无休止的自我包含。然而，结果并不是你想要的。