C++ 是否存在对称的设计模式，以便成员类可以彼此拥有指针？

我有一个更重要的设计问题。我有一个类，比如说S类，它有两个成员类，P和C。P类需要从C类调用成员函数，P类需要从C类调用成员函数

现在我处理这个问题的方法是首先创建C并将其传递给p，然后使p成为静态的，这样就可以从C访问其成员函数（以后我可能会有一个C类数组，但我总是有一个p，这就是为什么我可以使其成为静态的原因）

我的问题是，有没有更好的方法来建立这个？我不喜欢使P是静态的——理想情况下，我希望C和P有指向彼此的指针，但是如何呢

附上一些过于简化的代码

谢谢

#include <iostream>

class C;

class P {
   C *c;
   P (C *x ): c(x)  {};

 public:
    static P *p;
    static P *get_P(C *x) { if (!p) { p= new P(x);}; return p;};
    static P *get_P () { return p;}

    void P_function ();
    void P_other ();
};

class C {
  public:
    C ()  {};
    void C_function ()
    {
      std::cout << "in C_funtion\n";
    }
    void C_other ()
    {
      P::get_P()->P_function();
    }
};

void P::P_other ()
{
  c->C_function();
}

void P::P_function ()
{
  std::cout << "in P_funtion\n";
}

class S {
  public:
  C c;

  S()
  {
     P::get_P(&c);
  };
};

P* P::p = NULL;

int main ()
{
  S s;

  s.c.C_other();
  P::get_P()->P_other();

#包括
丙级;；
P类{
C*C；
P（C*x）：C（x）{}；
公众：
静态P*P；
静态P*get_P（C*x）{if（！P）{P=newp（x）；}；返回P；}；
静态P*get_P（）{return P；}
void P_函数（）；
无效P_其他（）；
};
C类{
公众：
C（）{}；
void C_函数（）
{
std:：cout P_函数（）；
}
};
无效P：：P_其他（）
{
c->c_函数（）；
}
void P:：P_函数（）
{
std：：cout P_other（）；

---

}

在头文件中，不包含其他类，只做一个转发声明，并使用指针：

// C.h
#ifndef C_H
#define C_H
class P;

class C 
{
     P *p;
public: 
     C (P *x ); 
     // *** no inline implementation of methods calling P methods here!!
}
#endif

p也一样，但不要通过构造函数传递C对象，而是通过一个单独的方法将其传递到p对象中（以避免在构造两个对象时出现明显的母鸡或鸡蛋问题）

在CPP文件中，在p.CPP中包含C.h，在C.CPP中包含p.h，然后可以在C中调用p的方法，反之亦然

---

现在在类S中，首先创建一个p对象，然后创建一个将p对象传递给它的C对象，最后使用

SetC

将C对象传递给p。也许您应该问问自己，这种循环依赖是否真的必要。可能有这样的情况，但在我看来，这种情况很少发生。

// P.h
#ifndef P_H
#define P_H
class C;

class P 
{
     C *c;
public: 
     P (); 
     void SetC(C *x){c=x;}
}
#endif