解决由于类之间的循环依赖而导致的构建错误

Question

我经常发现自己在 C++ 项目中面临多个编译/链接器错误，这是由于一些错误的设计决策（由其他人做出的:)）导致不同头文件中的 C++ 类之间的循环依赖(也可能发生在同一个文件中）。 但幸运的是（？）这种情况发生的频率并不高，以至于我无法在下次再次发生时记住该问题的解决方案。

因此，为了将来方便回忆，我将发布一个有代表性的问题和解决方案。 当然欢迎更好的解决方案。

---

• 啊

  <前><代码>B类； A级 { int_val； B*_b； 民众： A（整数值） :_val(val) { } 无效 SetB(B *b) { _b = b; _b->打印(); // 编译器错误：C2027：使用未定义的类型“B” } 无效打印（） { cout<<"类型：A val="<<_val<

---

• Bh

  <前><代码>#include“啊” B级 { 双_val； A* _a; 民众： B(双值) :_val(val) { } 无效 SetA(A *a) { _a = a； _a->打印(); } 无效打印（） { cout<<"类型：B val="<<_val<

---

• main.cpp

  <前><代码>#include“Bh” #include ; int main(int argc, char* argv[]) { 一个(10); Bb(3.14)； 打印（）; a.SetB(&b); b.打印(); b.SetA(&a); 返回0； }

Answer 1

思考这个问题的方法是“像编译器一样思考”。

想象一下您正在编写一个编译器。 你会看到这样的代码。

// file: A.h
class A {
  B _b;
};

// file: B.h
class B {
  A _a;
};

// file main.cc
#include "A.h"
#include "B.h"
int main(...) {
  A a;
}

当您编译.cc文件时（请记住.cc而不是.h是编译的单位），您需要为对象A分配空间。 那么，那么，有多少空间呢？ 足够存储B！ 那么B的大小是多少？ 足够存储 A！ 哎呀。

显然，这是一个必须打破的循环引用。

您可以通过允许编译器保留尽可能多的空间来打破它 - 例如，指针和引用将始终是 32 或 64 位（取决于体系结构），因此如果您将（其中之一）替换为一个指针或参考，事情会很棒。 假设我们替换为 A：

// file: A.h
class A {
  // both these are fine, so are various const versions of the same.
  B& _b_ref;
  B* _b_ptr;
};

现在情况好多了。 有些。 main() 仍然显示：

// file: main.cc
#include "A.h"  // <-- Houston, we have a problem

#include，出于所有范围和目的（如果您取出预处理器），只需将文件复制到 .cc。 所以实际上， .cc 看起来像：

// file: partially_pre_processed_main.cc
class A {
  B& _b_ref;
  B* _b_ptr;
};
#include "B.h"
int main (...) {
  A a;
}

你可以看到为什么编译器不能处理这个 - 它不知道 B 是什么 - 它甚至从未见过之前的符号。

因此，让我们告诉编译器有关 B 的信息。 这称为前向声明，并在 这个答案。

// main.cc
class B;
#include "A.h"
#include "B.h"
int main (...) {
  A a;
}

这有效。 这不是很好。 但此时您应该了解循环引用问题以及我们为“修复”它所做的事情，尽管修复很糟糕。

此修复不好的原因是因为下一个 #include "Ah" 的人必须先声明 B 才能使用它，并且会得到一个可怕的 #包括错误。 因此，让我们将声明移至 Ah 本身。

// file: A.h
class B;
class A {
  B* _b; // or any of the other variants.
};

而在Bh中，此时直接#include "Ah"即可。

// file: B.h
#include "A.h"
class B {
  // note that this is cool because the compiler knows by this time
  // how much space A will need.
  A _a; 
}

HTH。

Answer 2

如果从头文件中删除方法定义并让类仅包含方法声明和变量声明/定义，则可以避免编译错误。 方法定义应放置在 .cpp 文件中（就像最佳实践指南所述）。

以下解决方案的缺点是（假设您已将方法放入头文件中以内联它们），编译器不再内联这些方法，并且尝试使用 inline 关键字会产生链接器错误。

//A.h
#ifndef A_H
#define A_H
class B;
class A
{
    int _val;
    B* _b;
public:

    A(int val);
    void SetB(B *b);
    void Print();
};
#endif

//B.h
#ifndef B_H
#define B_H
class A;
class B
{
    double _val;
    A* _a;
public:

    B(double val);
    void SetA(A *a);
    void Print();
};
#endif

//A.cpp
#include "A.h"
#include "B.h"

#include <iostream>

using namespace std;

A::A(int val)
:_val(val)
{
}

void A::SetB(B *b)
{
    _b = b;
    cout<<"Inside SetB()"<<endl;
    _b->Print();
}

void A::Print()
{
    cout<<"Type:A val="<<_val<<endl;
}

//B.cpp
#include "B.h"
#include "A.h"
#include <iostream>

using namespace std;

B::B(double val)
:_val(val)
{
}

void B::SetA(A *a)
{
    _a = a;
    cout<<"Inside SetA()"<<endl;
    _a->Print();
}

void B::Print()
{
    cout<<"Type:B val="<<_val<<endl;
}

//main.cpp
#include "A.h"
#include "B.h"

int main(int argc, char* argv[])
{
    A a(10);
    B b(3.14);
    a.Print();
    a.SetB(&b);
    b.Print();
    b.SetA(&a);
    return 0;
}

Answer 3

我迟到了回答这个问题，但迄今为止还没有一个合理的答案，尽管这是一个热门问题，答案得到了高度赞扬......

最佳实践：前向声明标头

如标准库的 标头，为其他人提供前向声明的正确方法是拥有一个前向声明标头。 例如：

a.fwd.h:

#pragma once
class A;

ah:

#pragma once
#include "a.fwd.h"
#include "b.fwd.h"

class A
{
  public:
    void f(B*);
};

b.fwd.h:

#pragma once
class B;

bh:

#pragma once
#include "b.fwd.h"
#include "a.fwd.h"

class B
{
  public:
    void f(A*);
};

A 和 B 库的维护者应该各自负责保留其前向声明标头与其标头和实现文件同步，因此 - 例如 - 如果“B”的维护者出现并将代码重写为...

b.fwd.h:

template <typename T> class Basic_B;
typedef Basic_B<char> B;

bh:

template <typename T>
class Basic_B
{
    ...class definition...
};
typedef Basic_B<char> B;

...然后重新编译代码“A”将由对所包含的 b.fwd.h 的更改触发，并且应该干净地完成。

---

糟糕但常见的做法：在其他库中转发声明内容

说 - 不要使用上面解释的转发声明标头 - 使用 ah 或 a.cc 中的代码代替转发声明 < code>class B; 本身：

• 如果 ah 或 a.cc 稍后确实包含 bh：
  • 一旦遇到 B 的冲突声明/定义，A 的编译将终止并出现错误（即上述对 B 的更改破坏了 A 和任何其他滥用前向声明的客户端，而不是透明地工作） ）。
• 否则（如果 A 最终没有包含 bh - 如果 A 只是通过指针和/或引用存储/传递 B，则可能）
  • 依赖 #include 分析和更改的文件时间戳的构建工具在更改为 B 后不会重建 A（及其进一步依赖的代码），从而导致错误链接时间或运行时间。 如果 B 作为运行时加载的 DLL 进行分发，“A”中的代码可能无法在运行时找到不同损坏的符号，这些符号可能会或可能不会处理得足够好以触发有序关闭或可接受的减少功能。

如果 A 的代码具有旧 B 的模板专业化/“特征”，它们将不会生效。

Answer 4

需要记住的事情：

• 如果A 类 具有B 类 的对象作为成员，则此方法将不起作用，反之亦然。
• 向前声明是一条路要走。
• 声明的顺序很重要（这就是您要删除定义的原因）。
  • 如果两个类都调用另一个类的函数，则必须将定义移出。

阅读常见问题解答：

• 如何创建两个彼此了解的类？
• 当前向声明与成员对象？
• 前向声明时需要哪些特殊注意事项与内联函数一起使用吗？

Answer 5

我曾经通过将所有内联移动到类定义之后并将其他类的#include放在内联之前解决了此类问题头文件。 这样可以确保在解析内联之前设置所有定义+内联。

这样做使得两个（或多个）头文件中仍然可以有一堆内联。 但有必要包括警卫。

像这样

// File: A.h
#ifndef __A_H__
#define __A_H__
class B;
class A
{
    int _val;
    B *_b;
public:
    A(int val);
    void SetB(B *b);
    void Print();
};

// Including class B for inline usage here 
#include "B.h"

inline A::A(int val) : _val(val)
{
}

inline void A::SetB(B *b)
{
    _b = b;
    _b->Print();
}

inline void A::Print()
{
    cout<<"Type:A val="<<_val<<endl;
}

#endif /* __A_H__ */

......并在 Bh 中做同样的事情

Answer 6

我曾经写过一篇关于此的文章： 解决 c++ 中的循环依赖

基本技术是使用接口来解耦类。 所以在你的情况下：

//Printer.h
class Printer {
public:
    virtual Print() = 0;
}

//A.h
#include "Printer.h"
class A: public Printer
{
    int _val;
    Printer *_b;
public:

    A(int val)
        :_val(val)
    {
    }

    void SetB(Printer *b)
    {
        _b = b;
        _b->Print();
    }

    void Print()
    {
        cout<<"Type:A val="<<_val<<endl;
    }
};

//B.h
#include "Printer.h"
class B: public Printer
{
    double _val;
    Printer* _a;
public:

    B(double val)
        :_val(val)
    {
    }

    void SetA(Printer *a)
    {
        _a = a;
        _a->Print();
    }

    void Print()
    {
        cout<<"Type:B val="<<_val<<endl;
    }
};

//main.cpp
#include <iostream>
#include "A.h"
#include "B.h"

int main(int argc, char* argv[])
{
    A a(10);
    B b(3.14);
    a.Print();
    a.SetB(&b);
    b.Print();
    b.SetA(&a);
    return 0;
}

Answer 7

这是模板的解决方案： 如何处理与模板的循环依赖

解决此问题的线索是在提供定义（实现）之前声明这两个类。 无法将声明和定义拆分为单独的文件，但您可以将它们结构化，就像它们位于单独的文件中一样。

Answer 8

维基百科上提供的简单示例对我有用。
（您可以在 http://en.wikipedia.org/wiki 阅读完整说明/Circular_dependency#Example_of_circular_dependency_in_C.2B.2B )

文件 '''ah''':

#ifndef A_H
#define A_H

class B;    //forward declaration

class A {
public:
    B* b;
};
#endif //A_H

文件 '''bh''':

#ifndef B_H
#define B_H

class A;    //forward declaration

class B {
public:
    A* a;
};
#endif //B_H

文件 '''main.cpp''':

#include "a.h"
#include "b.h"

int main() {
    A a;
    B b;
    a.b = &b;
    b.a = &a;
}

Answer 9

不幸的是，之前的所有答案都缺少一些细节。 正确的解决方案有点麻烦，但这是唯一正确的方法。 而且它可以轻松扩展，还可以处理更复杂的依赖关系。

以下是您如何做到这一点，完全保留所有细节和可用性：

• 完全相同，
• 解决方案与最初预期的内联函数
• A 和 B 的内联用户仍然可以包括Ah 和 Bh 以任意顺序

创建两个文件，A_def.h、B_def.h。 这些将仅包含 A 和 B 的定义：

// A_def.h
#ifndef A_DEF_H
#define A_DEF_H

class B;
class A
{
    int _val;
    B *_b;

public:
    A(int val);
    void SetB(B *b);
    void Print();
};
#endif

// B_def.h
#ifndef B_DEF_H
#define B_DEF_H

class A;
class B
{
    double _val;
    A* _a;

public:
    B(double val);
    void SetA(A *a);
    void Print();
};
#endif

然后，Ah 和 Bh 将包含以下内容：

// A.h
#ifndef A_H
#define A_H

#include "A_def.h"
#include "B_def.h"

inline A::A(int val) :_val(val)
{
}

inline void A::SetB(B *b)
{
    _b = b;
    _b->Print();
}

inline void A::Print()
{
    cout<<"Type:A val="<<_val<<endl;
}

#endif

// B.h
#ifndef B_H
#define B_H

#include "A_def.h"
#include "B_def.h"

inline B::B(double val) :_val(val)
{
}

inline void B::SetA(A *a)
{
    _a = a;
    _a->Print();
}

inline void B::Print()
{
    cout<<"Type:B val="<<_val<<endl;
}

#endif

请注意，A_def.h 和 B_def.h 是“私有”标头，A 和 B 的用户不应使用它们。 公共标头是 Ah 和 Bh

Answer 10

不幸的是我无法评论geza的答案。

他不仅仅是说“将声明放入单独的标头中”。 他说，您必须将类定义标头和内联函数定义溢出到不同的标头文件中，以允许“延迟依赖项”。

但他的插图并不好。 因为两个类（A 和 B）只需要彼此不完整的类型（指针字段/参数）。

为了更好地理解它，想象一下 A 类有一个类型为 B 而不是 B* 的字段。 另外，类 A 和 B 想要定义一个带有其他类型参数的内联函数：

这个简单的代码不起作用：

// A.h
#pragme once
#include "B.h"

class A{
  B b;
  inline void Do(B b);
}

inline void A::Do(B b){
  //do something with B
}

// B.h
#pragme once
class A;

class B{
  A* b;
  inline void Do(A a);
}

#include "A.h"

inline void B::Do(A a){
  //do something with A
}

//main.cpp
#include "A.h"
#include "B.h"

它将产生以下代码：

//main.cpp
//#include "A.h"

class A;

class B{
  A* b;
  inline void Do(A a);
}

inline void B::Do(A a){
  //do something with A
}

class A{
  B b;
  inline void Do(B b);
}

inline void A::Do(B b){
  //do something with B
}
//#include "B.h"

该代码无法编译，因为 B::Do 需要 A 的完整类型稍后定义。

为了确保它编译源代码应该如下所示：

//main.cpp
class A;

class B{
  A* b;
  inline void Do(A a);
}

class A{
  B b;
  inline void Do(B b);
}

inline void B::Do(A a){
  //do something with A
}

inline void A::Do(B b){
  //do something with B
}

对于每个需要定义内联函数的类来说，这两个头文件完全可以实现。
唯一的问题是循环类不能只包含“公共标头”。

为了解决这个问题，我想建议一个预处理器扩展：#pragma process_pending_includes

该指令应该推迟当前文件的处理并完成所有挂起的包含。

Answer 11

首先我们需要一些定义。

定义

声明

extern int n;
int f();
template<typename T> int g(T);
struct A;
template<typename T> struct B;

定义

int n;
int f() { return 42; }
template<typename T> int g(T) { return 42; }
struct A { int f(); };
template<typename T> struct B { int g(T*); };

区别在于重复定义会导致一个定义规则 (ODR) 违规。 编译器将给出类似“error: redefinition of '...'”的错误。

请注意，“前向声明”只是一个声明。 声明可以重复，因为它们没有定义任何内容，因此不会导致 ODR。

请注意，默认参数只能给出一次，可能是在声明期间，但如果有多个声明，则仅适用于其中一个声明。 因此，有人可能会说这是一个定义，因为它可能不会重复（从某种意义上说它是：它定义了默认参数）。 但是，由于它没有定义函数或模板，所以无论如何我们都将它们称为声明。 下面将忽略默认参数。

函数定义

（成员）函数定义生成代码。 拥有多个这些（在不同的翻译单元 (TU) 中，否则在编译时就会发生 ODR 冲突）通常会导致链接器错误； 除非链接器解决了它为内联函数和模板化函数所做的冲突。 两者都可能内联，也可能不内联； 如果它们不是 100% 内联，则需要存在一个正常函数（实例化）； 这可能会导致我所说的碰撞。

非内联、非模板（成员）函数只需存在于单个 TU 中，因此应在单个 .cpp 中定义。

然而，内联和/或模板（成员）函数是在标头中定义的，它们可能包含在多个 TU 中，因此需要链接器进行特殊处理。 然而，它们也被认为可以生成代码。

类定义

类定义可能会也可能不会生成代码。 如果是这样，那么链接器将解决其任何冲突的函数。

当然，类内部定义的任何成员函数根据定义都是“内联”的。 如果在类声明期间定义这样的函数存在问题，只需将其移到类声明之外即可。

因此，

struct A {
  int f() const { return 42; }
};

我们

struct A {
  inline int f() const;
}; // struct declaration ends here.

int A::f() const { return 42; }

最感兴趣的是代码生成（函数实例化），两者都不能移动到类声明之外，并且需要一些其他定义才能实现实例化。

事实证明，这通常涉及智能指针和默认析构函数。 假设 struct B 无法定义，只能声明，并且 struct A 如下所示：

struct B;
struct A { std::unique_ptr<B> ptr; };

然后是 A 的实例化，而 A 的定义code>B 不可见（某些编译器可能不介意 B 是否稍后在同一 TU 中定义）将导致错误，因为 B 的默认构造函数以及析构函数code>A，导致生成unique_ptr的析构函数，需要B的定义[例如error: invalid application of 'sizeof' 为不完整类型 'B']。 不过，仍然有一种方法可以解决这个问题：不要使用生成的默认构造函数/析构函数。

例如，

struct B;
struct A {
  A();
  ~A();
  std::unique_ptr<B> ptr;
};

将编译并且只有 A::A() 和 A::~A() 两个未定义的符号，您仍然可以在定义之外内联编译它们像以前一样的 A （前提是您在执行此操作之前定义了 B）。

三个部分，三个文件？

因此，我们可以区分结构/类定义的三个部分，我们可以将它们分别放入不同的文件中。

1. （转发）声明：

   A.fwd.h

2. 类定义：

   啊

3. 内联和模板成员函数定义：

   A.inl.h

当然还有包含非内联和非模板成员函数定义的 A.cpp； 但这些与循环标头依赖性无关。

忽略默认参数，声明不需要任何其他声明或定义。

类定义可能需要声明某些其他类，还需要定义其他类。

内联/模板成员函数可能需要额外的定义。

因此，我们可以创建以下示例来显示所有可能性：

struct C;
struct B
{
  B();
  ~B();
  std::unique_ptr<C> ptr;  // Need declaration of C.
};

struct A
{
  B b;    // Needs definition of B.
  C f();  // Needs declaration of C.
};

inline A g()  // Needs definition of A.
{
  return {};
}

struct D
{
  A a = g();  // Needs definition of A.
  C c();      // Needs declaration of C.
};

其中 B::B(), B::~B(), CA::f( ) 和 CD::c() 在一些 .cpp 中定义。

但是，我们也可以内联它们； 此时我们需要定义 C 因为所有四个都需要它（B::B 和 B::~B 因为 >unique_ptr，见上文）。 在这个 TU 中这样做突然使得没有必要将 B::B() 和 B::~B() 放在 B 的定义之外 （至少对于我正在使用的编译器）。 尽管如此，让 B 保持原样。

然后我们得到：

// C.fwd.h:
struct C;

// B.h:
struct B
{
  inline B();
  inline ~B();
  std::unique_ptr<C> ptr;
};

// A.h:
struct A
{
  B b;
  inline C f();
};

// D.h:
inline A g()
{
  return {};
}
struct D
{
  A a = g();
  inline C c();
};

// C.h:
struct C {};

// B.inl.h:
B::B() {}
B::~B() {}

// A.inl.h:
C A::f()
{
  D d;
  return d.c();
}

// D.inl.h:
C D::c()
{
  return {};
}

换句话说，A 的定义如下所示：

// A.fwd.h:
struct A;

// A.h:
#include "B.h"      // Already includes C.fwd.h, but well...
#include "C.fwd.h"  // We need C to be declared too.
struct A
{
  B b;
  inline C f();
};

// A.inl.h:
#include "A.h"
#include "C.h"
#include "D.inl.h"
C A::f()
{
  D d;
  return d.c();
}

请注意，理论上我们可以创建多个 .inl.h 标头：每个函数一个，如果否则，它会拖拽超过所需的时间，从而导致问题。

禁止的模式

请注意，所有#include 都位于所有文件的顶部。

（理论上）.fwd.h 标头不包含其他标头。 因此它们可以随意包含并且永远不会导致循环依赖。

.h 定义标头可能包含 .inl.h 标头，但如果这导致循环标头依赖项，则始终可以通过移动使用内联的函数来避免这种情况函数从 .inl.h 到当前类的 .inl.h； 对于智能指针，可能还需要将析构函数和/或构造函数移动到该 .inl.h。

因此，唯一剩下的问题是 .h 定义标头的循环包含，即 Ah 包含 Bh 和 Bh包括啊。 在这种情况下，您必须通过用指针替换类成员来解耦循环。

最后，不可能有纯 .inl.h 文件的循环。 如果有必要，您可能应该将它们移动到单个文件中，在这种情况下，编译器可能无法解决问题； 但显然，当所有函数相互使用时，您无法内联所有函数，因此您不妨手动决定哪些函数可以是非内联的。

Answer 12

在某些情况下，可以在类 A 的头文件中定义类 B 的方法或构造函数来解决涉及定义的循环依赖。
通过这种方式，您可以避免将定义放入 .cc 文件中，例如，如果您想实现仅包含头文件的库。

// file: a.h
#include "b.h"
struct A {
  A(const B& b) : _b(b) { }
  B get() { return _b; }
  B _b;
};

// note that the get method of class B is defined in a.h
A B::get() {
  return A(*this);
}

// file: b.h
class A;
struct B {
  // here the get method is only declared
  A get();
};

// file: main.cc
#include "a.h"
int main(...) {
  B b;
  A a = b.get();
}