c++ inheritance指针

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.
    };

Answer 2

wouldn't Base_A have a pointer to Base_B if Base_A::init() was ever called? why wouldn't you init the base class?