Question

it’s pretty diffecult for me to describe my problem.
I have two classes, I would say Base_A and Derived_A. You can see from the names, the class Derived_A is derived from Base_A. Also in my program I have other two classes Base_B and Derived_B (also with inheritance). The class Base_A contains the object of Base_B, and the class Derived_A contains the object of Derived_B.

class Base_A {
public:
    Base_A() {}
    virtual ~Base_A() {}

    Base_B b_;
    Base_B* pointer_;

    void init() {
        b_ = Base_B();
        pointer_ = &b_;
        pointer_->setValue(1);
    }

    void print() {
        pointer_->getValue();

    }
};

class Derived_A: public Base_A {
public:
    Derived_A() {}
    virtual ~Derived_A() {}

    Derived_B b_;
    Derived_B* pointer_;

    void init() {
        b_ = Derived_B();
        pointer_ = &b_;
        pointer_->setValue(2);
        pointer_->increaseValue();
    }
};

class Base_B {
public:
    Base_B() {}
    virtual ~Base_B() {}

    int value_;

    void setValue(int value) {
        value_ = value;
    }

    void getValue() {
        cout << "Base_B: " << value_ << endl;
    }
};

class Derived_B: public Base_B {
public:
    Derived_B() {}
    virtual ~Derived_B() {}

    void increaseValue() {
        value_++;
    }
};

int main() {  
    Derived_A derived_A = Derived_A();
    derived_A.init();
    derived_A.print();

    return 0;
}

How you can see every class of A has one object of class B and pointer to this object. My problem is, when I call the function print(), it does not take Derived_B* pointer_, but try to access Base_B* pointer_, which is not exist. How I can say in my program, that it should take the pointer according to the class? Or do I need to declarate the Base_B* pointer_ inside the Derived_A class like:

Base::pointer_ = pointer_;

Maybe is there other method or algorithm for my problem?

Thank you a lot.

Answer 1

“but try to access Base_B* pointer_, which is not exist”

If DerivedA does not properly initialise BaseA, then DerivedA does not meet the “isA” rule for inheritance and the design needs changed. On the face of things:

1. Don’t re-use names in the derived class such as b_, pointer_.
   Its just confusing and you gain no value.
2. Make init() virtual.
3. Have DerivedA::init() call BaseA::init() explicitly.
4. Make pointer_ a virtual method.

Note the use of “covariant return types” for the virtual methods.

class BaseA
    {
    public:
       virtual BaseB* pointer() { return &b_; }
       // etc.
    };

class DerivedA : public BaseA
    {
    public:
       virtual DerivedB* pointer() { return &b_; }
       // etc.
    };