类中的多个构造函数

Multiple constructors in a class

本文关键字：构造函数      更新时间：2023-10-16

我有类A,B,C,D，它们都有一个X类的成员。我还有一个班叫P班。

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

so代码看起来像;

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，因为这会很复杂，因为这些类不是我写的。除了上述两种方法之外，还有其他方法可以做到这一点吗?

任何帮助都会很感激。谢谢。

如果您只需要访问每个类中的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);
    }
};

有很多关于你的类之间的关系的信息，以及你可以或不可以改变哪些类，这些信息是缺失的，以便我完全了解你需要什么。然而，在我看来，将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() {
        ...
    }
};
相关文章：