有没有对称设计模式，所以成员类可以指向彼此？

我有更多的设计问题。我有一类，说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();

}

来源

2012-02-29 user993833

也许你应该问自己，如果这个循环依赖是非常必要的。可能会出现这种情况，但在我看来他们很少。 – Nobody 2012-02-29 18:51:07

在你的头文件，使没有包括其他类，只有一个向前声明和使用指针：

// 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对象中（以避免在构造两个对象时出现明显的鸡蛋或鸡蛋问题）。

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

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

在你的CPP文件，包括C.h在P.cpp和P.h在C.cpp，那么你可以调用用C P的方法，反之亦然。

现在在你的S类中，首先创建一个P对象，然后创建一个将P对象传递给它的C对象，最后通过使用SetC将C对象传递给P。

来源

2012-02-29 18:08:29

有没有对称设计模式，所以成员类可以指向彼此？

回答

相关问题