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

假设您正在编写一个编译器。你会看到这样的代码。

// 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“A.h”的人在使用它之前必须声明B，并且会得到一个可怕的#include错误。让我们把声明移到A.h本身。

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

在B.h中，此时你可以直接包含“A.h”。

// 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.

我曾经解决过这类问题，方法是将所有内联移到类定义之后，并将其他类的#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__ */

.．.在B.h中做同样的事情

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

假设您正在编写一个编译器。你会看到这样的代码。

// 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“A.h”的人在使用它之前必须声明B，并且会得到一个可怕的#include错误。让我们把声明移到A.h本身。

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

在B.h中，此时你可以直接包含“A.h”。

// 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.

我曾经写过一篇关于这个问题的文章:在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;
}

需要记住的事情:

如果类A有类B的对象作为成员，这将不起作用，反之亦然。 向前申报是一种方式。 声明的顺序很重要(这就是为什么要移出定义)。 如果两个类都调用另一个类的函数，则必须将定义移出。

阅读常见问题:

如何创建两个相互了解的类? 对成员对象使用前向声明时需要特别注意什么? 前向声明与内联函数一起使用时需要特别注意什么?

我回答这个问题晚了，但到目前为止还没有一个合理的答案，尽管这是一个受欢迎的问题，得到了高度好评的答案....

最佳实践:向前声明标头

正如标准库的<iosfwd>标头所示，为其他人提供前向声明的正确方法是有一个前向声明标头。例如:

a.fwd.h:

#pragma once
class A;

a.h:

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

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

b.fwd.h:

#pragma once
class B;

b.h:

#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;

b.h:

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

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

糟糕但常见的做法:在其他lib中向前声明东西

比如，不是像上面解释的那样使用前向声明头，而是在a.h或a.cc中使用前向声明类B;本身:

if a.h or a.cc did include b.h later: compilation of A will terminate with an error once it gets to the conflicting declaration/definition of B (i.e. the above change to B broke A and any other clients abusing forward declarations, instead of working transparently). otherwise (if A didn't eventually include b.h - possible if A just stores/passes around Bs by pointer and/or reference) build tools relying on #include analysis and changed file timestamps won't rebuild A (and its further-dependent code) after the change to B, causing errors at link time or run time. If B is distributed as a runtime loaded DLL, code in "A" may fail to find the differently-mangled symbols at runtime, which may or may not be handled well enough to trigger orderly shutdown or acceptably reduced functionality.

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