C++ 循环依赖关系？

好的，我理解转发声明，但在这种情况下，我需要在两端调用成员/字段，所以我不能使用它。我试图覆盖.cpp文件中的声明（通过包含我需要使用的类的实际头），但我在头中通过前向声明定义的指针在尝试使用它时被破坏

---

我怎样才能避开这件事？你需要代码吗？

如果你是唯一一个可以访问代码内部的人（比如当你自己做一个项目时，独自一人，或者分发一个封闭的.lib/.dll），并且你肯定你需要你的类以循环的方式包含它们自己，那么你总是可以使用一个抽象基类

class base{};

class A: public base{
   base *bMember;
};

class B: public base{
   base *aMember;
};

---

这是一个有点糟糕的做法，但如果你需要一个直接的解决方案，它应该是足够的。更好的方法是修复依赖项或使用单独的基类。

如果您是唯一一个可以访问代码内部的人（例如，当您自己做一个项目时，独自一人，或者分发一个封闭的.lib/.dll），并且确定您需要您的类以循环方式包含它们自己，您可以始终使用抽象基类

class base{};

class A: public base{
   base *bMember;
};

class B: public base{
   base *aMember;
};

---

这是一个有点糟糕的做法，但如果你需要一个直接的解决方案，它应该是足够的。更好的方法是修复依赖项或使用单独的基类。

如果您是唯一一个可以访问代码内部的人（例如，当您自己做一个项目时，独自一人，或者分发一个封闭的.lib/.dll），并且确定您需要您的类以循环方式包含它们自己，您可以始终使用抽象基类

class base{};

class A: public base{
   base *bMember;
};

class B: public base{
   base *aMember;
};

---

这是一个有点糟糕的做法，但如果你需要一个直接的解决方案，它应该是足够的。更好的方法是修复依赖项或使用单独的基类。

如果您是唯一一个可以访问代码内部的人（例如，当您自己做一个项目时，独自一人，或者分发一个封闭的.lib/.dll），并且确定您需要您的类以循环方式包含它们自己，您可以始终使用抽象基类

class base{};

class A: public base{
   base *bMember;
};

class B: public base{
   base *aMember;
};

---

这是一个有点糟糕的做法，但如果你需要一个直接的解决方案，它应该是足够的。更好的方法是修复依赖项或使用单独的基类。

您需要记住，形成指向类的指针只需要该类的声明，而访问该类的成员则需要其定义。因此，要解决循环依赖关系，可以执行以下操作：

A.hpp

class B;

class A
{
public:
  int foo(B *b);
  int bar();
};

class A;

class B
{
  A *m_a;
public:
  int foo();
  explicit B(A *a) : m_a(a) {}
};

#include "A.hpp"
#include "B.hpp"

int A::foo(B *b)
{
  return 2 * b->foo();
}

int A::bar()
{
  return 42;
}

#include "A.hpp"
#include "B.hpp"

int B::foo()
{
  return m_a->bar();
}

B.hpp

class B;

class A
{
public:
  int foo(B *b);
  int bar();
};

class A;

class B
{
  A *m_a;
public:
  int foo();
  explicit B(A *a) : m_a(a) {}
};

#include "A.hpp"
#include "B.hpp"

int A::foo(B *b)
{
  return 2 * b->foo();
}

int A::bar()
{
  return 42;
}

#include "A.hpp"
#include "B.hpp"

int B::foo()
{
  return m_a->bar();
}

A.cpp

class B;

class A
{
public:
  int foo(B *b);
  int bar();
};

class A;

class B
{
  A *m_a;
public:
  int foo();
  explicit B(A *a) : m_a(a) {}
};

#include "A.hpp"
#include "B.hpp"

int A::foo(B *b)
{
  return 2 * b->foo();
}

int A::bar()
{
  return 42;
}

#include "A.hpp"
#include "B.hpp"

int B::foo()
{
  return m_a->bar();
}

B.cpp

class B;

class A
{
public:
  int foo(B *b);
  int bar();
};

class A;

class B
{
  A *m_a;
public:
  int foo();
  explicit B(A *a) : m_a(a) {}
};

#include "A.hpp"
#include "B.hpp"

int A::foo(B *b)
{
  return 2 * b->foo();
}

int A::bar()
{
  return 42;
}

#include "A.hpp"
#include "B.hpp"

int B::foo()
{
  return m_a->bar();
}

---

您需要记住，形成指向类的指针只需要该类的声明，而访问该类的成员则需要其定义。因此，要解决循环依赖关系，可以执行以下操作：

A.hpp

class B;

class A
{
public:
  int foo(B *b);
  int bar();
};

class A;

class B
{
  A *m_a;
public:
  int foo();
  explicit B(A *a) : m_a(a) {}
};

#include "A.hpp"
#include "B.hpp"

int A::foo(B *b)
{
  return 2 * b->foo();
}

int A::bar()
{
  return 42;
}

#include "A.hpp"
#include "B.hpp"

int B::foo()
{
  return m_a->bar();
}

B.hpp

class B;

class A
{
public:
  int foo(B *b);
  int bar();
};

class A;

class B
{
  A *m_a;
public:
  int foo();
  explicit B(A *a) : m_a(a) {}
};

#include "A.hpp"
#include "B.hpp"

int A::foo(B *b)
{
  return 2 * b->foo();
}

int A::bar()
{
  return 42;
}

#include "A.hpp"
#include "B.hpp"

int B::foo()
{
  return m_a->bar();
}

A.cpp

class B;

class A
{
public:
  int foo(B *b);
  int bar();
};

class A;

class B
{
  A *m_a;
public:
  int foo();
  explicit B(A *a) : m_a(a) {}
};

#include "A.hpp"
#include "B.hpp"

int A::foo(B *b)
{
  return 2 * b->foo();
}

int A::bar()
{
  return 42;
}

#include "A.hpp"
#include "B.hpp"

int B::foo()
{
  return m_a->bar();
}

B.cpp

class B;

class A
{
public:
  int foo(B *b);
  int bar();
};

class A;

class B
{
  A *m_a;
public:
  int foo();
  explicit B(A *a) : m_a(a) {}
};

#include "A.hpp"
#include "B.hpp"

int A::foo(B *b)
{
  return 2 * b->foo();
}

int A::bar()
{
  return 42;
}

#include "A.hpp"
#include "B.hpp"

int B::foo()
{
  return m_a->bar();
}

---

您需要记住，形成指向类的指针只需要该类的声明，而访问该类的成员则需要其定义。因此，要解决循环依赖关系，可以执行以下操作：

A.hpp

class B;

class A
{
public:
  int foo(B *b);
  int bar();
};

class A;

class B
{
  A *m_a;
public:
  int foo();
  explicit B(A *a) : m_a(a) {}
};

#include "A.hpp"
#include "B.hpp"

int A::foo(B *b)
{
  return 2 * b->foo();
}

int A::bar()
{
  return 42;
}

#include "A.hpp"
#include "B.hpp"

int B::foo()
{
  return m_a->bar();
}

B.hpp

class B;

class A
{
public:
  int foo(B *b);
  int bar();
};

class A;

class B
{
  A *m_a;
public:
  int foo();
  explicit B(A *a) : m_a(a) {}
};

#include "A.hpp"
#include "B.hpp"

int A::foo(B *b)
{
  return 2 * b->foo();
}

int A::bar()
{
  return 42;
}

#include "A.hpp"
#include "B.hpp"

int B::foo()
{
  return m_a->bar();
}

A.cpp

class B;

class A
{
public:
  int foo(B *b);
  int bar();
};

class A;

class B
{
  A *m_a;
public:
  int foo();
  explicit B(A *a) : m_a(a) {}
};

#include "A.hpp"
#include "B.hpp"

int A::foo(B *b)
{
  return 2 * b->foo();
}

int A::bar()
{
  return 42;
}

#include "A.hpp"
#include "B.hpp"

int B::foo()
{
  return m_a->bar();
}

B.cpp

class B;

class A
{
public:
  int foo(B *b);
  int bar();
};

class A;

class B
{
  A *m_a;
public:
  int foo();
  explicit B(A *a) : m_a(a) {}
};

#include "A.hpp"
#include "B.hpp"

int A::foo(B *b)
{
  return 2 * b->foo();
}

int A::bar()
{
  return 42;
}

#include "A.hpp"
#include "B.hpp"

int B::foo()
{
  return m_a->bar();
}

---

您需要记住，形成指向类的指针只需要该类的声明，而访问该类的成员则需要其定义。因此，要解决循环依赖关系，可以执行以下操作：

A.hpp

class B;

class A
{
public:
  int foo(B *b);
  int bar();
};

class A;

class B
{
  A *m_a;
public:
  int foo();
  explicit B(A *a) : m_a(a) {}
};

#include "A.hpp"
#include "B.hpp"

int A::foo(B *b)
{
  return 2 * b->foo();
}

int A::bar()
{
  return 42;
}

#include "A.hpp"
#include "B.hpp"

int B::foo()
{
  return m_a->bar();
}

B.hpp

class B;

class A
{
public:
  int foo(B *b);
  int bar();
};

class A;

class B
{
  A *m_a;
public:
  int foo();
  explicit B(A *a) : m_a(a) {}
};

#include "A.hpp"
#include "B.hpp"

int A::foo(B *b)
{
  return 2 * b->foo();
}

int A::bar()
{
  return 42;
}

#include "A.hpp"
#include "B.hpp"

int B::foo()
{
  return m_a->bar();
}

A.cpp

class B;

class A
{
public:
  int foo(B *b);
  int bar();
};

class A;

class B
{
  A *m_a;
public:
  int foo();
  explicit B(A *a) : m_a(a) {}
};

#include "A.hpp"
#include "B.hpp"

int A::foo(B *b)
{
  return 2 * b->foo();
}

int A::bar()
{
  return 42;
}

#include "A.hpp"
#include "B.hpp"

int B::foo()
{
  return m_a->bar();
}

B.cpp

class B;

class A
{
public:
  int foo(B *b);
  int bar();
};

class A;

class B
{
  A *m_a;
public:
  int foo();
  explicit B(A *a) : m_a(a) {}
};

#include "A.hpp"
#include "B.hpp"

int A::foo(B *b)
{
  return 2 * b->foo();
}

int A::bar()
{
  return 42;
}

#include "A.hpp"
#include "B.hpp"

int B::foo()
{
  return m_a->bar();
}

---

您描述的相互依赖性表明存在设计缺陷。重新审视您的设计，消除这两种类型之间的紧密耦合。SSCCE将非常可爱。。。嗯，我有一个活动系统。我还有一个类a，它包含B类对象的指针，并管理这个对象。现在我希望类B发送事件，其中包含指向类a的指针。因此，所有类都需要相互了解（除了事件类，它只需要知道类a）。类B不需要知道类a的类型就可以向其发送事件。使用依赖注入。使类A从名为“EventReceiver”的类派生，然后将指向EventReceiver的指针存储在类B中。请参阅事件不是由A或B处理的。类B需要知道“Event”。“事件”需要知道A类。A类需要知道B类。您描述的相互依赖性表明存在设计缺陷。重新审视您的设计，消除这两种类型之间的紧密耦合。SSCCE将非常可爱。。。嗯，我有一个活动系统。我还有一个类a，它包含B类对象的指针，并管理这个对象。现在我希望类B发送事件，其中包含指向类a的指针。因此，所有类都需要相互了解（除了事件类，它只需要知道类a）。类B不需要知道类a的类型就可以向其发送事件。使用依赖注入。使类A从名为“EventReceiver”的类派生，然后将指向EventReceiver的指针存储在类B中。请参阅事件不是由A或B处理的。类B需要知道“Event”。“事件”需要知道A类。A类需要知道B类。您描述的相互依赖性表明存在设计缺陷。重新审视您的设计，消除这两种类型之间的紧密耦合。SSCCE将非常可爱。。。嗯，我有一个活动系统。我还有一个类a，它包含B类对象的指针，并管理这个对象。现在我希望类B发送事件，其中包含指向类a的指针。因此，所有类都需要相互了解（除了事件类，它只需要知道类a）。类B不需要知道类a的类型就可以向其发送事件。使用依赖注入。使类A从名为“EventReceiv”的类派生