Question

我有A，B，C，D类，其中都有一个X类成员。我有另一个叫做P级的课。

在我的班级A中，我也创建了一个P类的实例。在类PI中需要访问A的X实例和A的方法（此方法在类B，C，D中也可用，具有相同的方法签名和参数），因此我在初始化类时将类A传递给类P. p上。

所以代码看起来像;

class P;
class A{
public:
    X x;
    P *p;

    A(){
        x = new X();
    };

    void setData(){
        p =  new P(this);
    }
};


class P{
public:
    A *a;
    P(A *_A){
        a = _A;            
        a->x.resetVal();
    }
};

现在我需要在B，C，D类中创建P的实例，并将这些类的实例传递给P.

据我所知，要实现这一点，我必须使A，B，C，D成为新类（类Parent）的子类，并将类P的构造函数设置为接受类Parent实例，或者我必须为P类中的A，B，C，D类创建单独的构造函数。

class Parent {
    X x;
}
class P;
class A:: Parent{
    ...........//code
};


class P{
public:
    Parent *prnt;
    Impl(Parent *prnt){
        .........//code
    }
};

---------------------- OR -------------------------

class P{
public:
    A *a;
    B *a;
    C *a;
    D *a;

    Impl(A *_A){
        .............//code
    }

    Impl(B *_B){
        .............//code
    }

    Impl(C *_C){
        .............//code
    }

    .............//code
};

我不想改变A，B，C，D类，因为那些类很复杂，因为那些类不是我写的。除了上述两种方法之外，还有其他方法可以实现吗？

任何帮助将不胜感激。感谢。

Answer 1

如果您只需要访问每个类中的X实例，则可以将指向X实例的指针传递给P的构造函数。

class P {
public:
    X* x;
    P(X* _x) {
        x = _x;
        // code
    }
};

class A{
public:
    X x;
    P *p;

    A(){
        x = new X();
    };

    void setData(){
        p = new P(x);
    }
};

Answer 2

有很多关于你的课程之间关系的信息，以及你能够或不能改变哪些课程缺失的信息，以便我完全理解你的需要。但是，在我看来，将P作为模板类可能是一个解决方案：

template<typename T>
class P {
public:
    T *t_;
    P(T* t){
        t_ = t;            
        t->x.resetVal();
    }
};

如果对A，B，C，D类的X实例的访问权限不同，那么您也可以将其作为模板参数：

class X {
public:
    void doStuff() {};
};

class A {
public:
    X x_;
};

class B {
public:
    X y_;
};

template<typename T, X (T::*XAccessor)>
class P {
public:
    T* t_;
    P (T* t)
    : t_{t} {
    }

    void doStuffWithX() {
        (t_ ->* XAccessor).doStuff();
    }
};

void testDoingStuffWithX() {
    A a;
    B b;

    P<A, &A::x_> pa(&a);
    P<B, &B::y_> pb(&b);

    pa.doStuffWithX();
    pb.doStuffWithX();
}

如果您还需要统一操作不同的P模板实例，可以使用P作为模板化类的公共基类：

class P {
    virtual ~P() {}
    virtual void doSomething() = 0;
};


template<typename T>
class SpecificP : public P {
public:
    T *t_;
    SpecificP(T* t){
        t_ = t;            
        t->x.resetVal();
    }

    override void doSomething() {
        ...
    }
};

一个类中的多个构造函数

2 个答案: