C++ 消除循环依赖

我在编译循环依赖项时遇到问题。我做了一些研究，人们建议使用转发声明。我仍然有一个问题，因为具有转发声明的类正在使用来自转发类的方法。这导致编译器给我错误“类A有不完整的字段b”。我如何绕过循环依赖关系，其中A需要B，B需要A

A.h：

\ifndef A\u H_
#定义一个_
#包括
//#包括“B.h”
甲级
{
乙级;；
私人：
B B；
公众：
A（）；
~A（）；
void方法（）；
};
#恩迪夫

A.cpp：

#include <iostream>
#include "A.h"

A::A()
{
}

A::~A()
{
}

void A::method()
{
    b.method();
}

#包括
#包括“A.h”
A：：A（）
{
}
A:：~A（）
{
}
void A:：method（）
{
b、 方法（）；
}

B.h：

#ifndef B#H_
#定义B_H_
#包括
//#包括“A.h”
B类
{
甲级；
私人：
A A；
公众：
B（）；
~B（）；
void方法（）；
};
#恩迪夫

B.cpp：

#include <iostream>
#include "B.h"

B::B()
{
}

B::~B()
{
}

void B::method()
{
    a.method();
}

#包括
#包括“B.h”
B：：B（）
{
}
B:：~B（）
{
}
void B：：方法（）
{
a、 方法（）；
}

在至少一种情况下（无论是

A

还是

B

），您必须消除对完整类型的依赖。例如，下面我已经删除了

A

在

A.h

头文件中拥有完整类型的

B

的需要：

// A.h
class B;

// B used as a reference only, so the complete type
// is not needed at this time
class A
{
public:
   A(B& b) : b_(b) {}

   void method();

private:
   B& b_;
};

// A.cpp
// B is used, and the complete type is required
#include "B.h"

void A::f()
{
   b.method();
}

在至少一种情况下（无论是

A

还是

B

），您必须消除对完整类型的依赖。例如，下面我已经删除了

A

在

A.h

头文件中拥有完整类型的

B

的需要：

// A.h
class B;

// B used as a reference only, so the complete type
// is not needed at this time
class A
{
public:
   A(B& b) : b_(b) {}

   void method();

private:
   B& b_;
};

// A.cpp
// B is used, and the complete type is required
#include "B.h"

void A::f()
{
   b.method();
}

---

你的课不能上课。每个

A

都包含

B

，其中包含

A

，其中包含

B

，等等，无限期。

您的类无法工作。每个

A

都包含

B

，其中包含

A

，其中包含

B

，等等，无限期。

您可以尝试用指向其他类的指针替换其中一个成员：

class B;
class A
{
    private:
        B* b;
    public:
        A();
        ~A();
        void method();
};

---

您可以尝试用指向另一个类的指针替换其中一个成员：

class B;
class A
{
    private:
        B* b;
    public:
        A();
        ~A();
        void method();
};

---

这将不起作用，因为

A

需要完全了解

B

的大小，

B

需要与

A

相同的大小，这只有在看到完整声明后才能给出

以下内容无效：

class B;
class A {
   B b;
};

为什么?？我们为

A

的一个实例分配了多少空间

sizeof（A）=sizeof（B）=未定义

有一个解决方法，但是：

class B;
class A {
    B* b_ptr;
    B& b_ref;
};

---

这是完全有效的，因为指针和引用的大小是已知的，而不管它们指向什么类型。

这将不起作用，因为

A

需要完全了解

B

的大小，

B

需要与

A

相同的大小，只有看到完整的声明才能给出

以下内容无效：

class B;
class A {
   B b;
};

为什么?？我们为

A

的一个实例分配了多少空间

sizeof（A）=sizeof（B）=未定义

有一个解决方法，但是：

class B;
class A {
    B* b_ptr;
    B& b_ref;
};

---

这是完全有效的，因为指针和引用的大小是已知的，而不管它们指向什么类型。

因此对象

A

包含

B

，其中包含

A

，其中包含

B

，其中包含

A

，它包含一个

B

…在

B

中不能有

a

，在

a

中不能有

B

。你能做的就是在B中有一个指向a的指针，或者在a中有一个指向B的指针。一个对象

a

包含一个

B

，它包含一个

a

，它包含一个

a

，它包含一个

B

…在

B

中不能有

a

，在

a

中不能有

B

。你能做的就是在B中有一个指向a的指针，或者在a中有一个指向B的指针