C++ child to Parent to child relationships

[ChaoticDALO]

Hello, I am wondering if this is possible. If I have a parent class and a child that inherits the parent, the child can access a parents member function right? Well let's say we are in the parent member function that has just been accessed by a child. The program goes through some condition statements, comes true to a situation where it's true, and now needs to tell the child to do child member function x. Is that possible?

class parent{
doSomeChecks();
};

class child : public parent{
....
void xFunction();
void someFunction();
....
}
// =====================================
// the child function that calls a parent function doSomeChecks()
void child::someFunction(){
this->doSomeChecks();
}

// the parent function that has just been called by a child object.
void Parent::doSomeChecks(){

// this is where I want to call a child function from this parent class
// which has been called by a child object. Now how to call xFunction()?
}

// this function is the function I want to call from parent.
void child::xFunction(){
....
// do some work here
....
}

If anyone could shed some light on how and why this would or would not work would be super fantastic.
Thx.

[Laharl]

In Python, you could do this with __class__, I'm not really sure that C++ has anything that performs a similar task builtin, though you might be able to work it through a method in each class that returns a String with the class name, and the base class would need access to the child class's methods, via friend classes.

[weaknessforcats]

Yep. This is called the Hollywood Principle: Don't call us, we'll call you.

It is part of a design pattern called the Template Method, which you can research.

Here's how it works:

When a child object is created, it has a parent object embedded in it.

When the child calls a parent method, it is to the parent object that is embedded in the child. That parent object can then call a child method.

This works because the access specifiers public/private/protected are ignored when to comes to overriding.

Consider this:

class Parent
{
    private:
        virtual void MethodB() = 0;
    public:
        void MethodA();
 
 
};
void Parent::MethodA()
{
    this->MethodB();
}
class Child : public Parent
{
    private:
        void MethodB();
};
void Child::MethodB()
{
    cout << "You have called Child::MethodB()" << endl;
}
int main()
{
     Parent* obj = new Child;
     obj->MethodA();
}
 

Here the Child overrides the Parent MethodB. Then when a Child object is used with a Parent*, the call to Parent::MethodB is reallty a call to Child::MethodB because of the override.

The effect is a pointer to a Parent object has called a Child method, and in this case a private Child method since public/private/protected are ignored whe it comes to overriding.

The tecgnique is called separating the interface from the implementation. That is, the public Parent methods are the interface and the private Parent methods are the implementation. This leads to private virtual functions and this is considered today to be the correct way to design for polymorhism.