C++: Calling overloaded virtual methods with parameters of the same base class - c++

Question

My question is related to C++. I have two families of classes: "Floor" and "Object". The first and the second family has a virtual method named "Enter" (which is called when an object enters the floor).
I wish to distinguish the behavior of "Enter" based on the sub-class of a "Floor" and "Object" respectively.
So I overload the method "Enter" with derived classes as the parameters. I have got code that works correctly, but requires two steps to call proper method, and would like to ask whether it can be done in one function call:
Edit: I updated the code (now full working example) with the potential solution. I have used a pointer to method with casting to retrieve proper overloaded method. This pointer is initialized in the constructors of the derived "Floor" classes.
#include <iostream>
using namespace std;
class Floor;
class Flagstone;
class Object
{
public:
virtual void Enter(Floor *f); /* Generic object enters generic floor */
virtual void Enter(Flagstone *fs); /* Generic object enters flagstone */
};
class Box : public Object
{
public:
void Enter(Floor *f);
void Enter(Flagstone *fs);
};
class Floor
{
public:
typedef void (Object::*enterPtr)(Floor *);
enterPtr enter; /* Pointer to method, initialized by constructor */
Floor(enterPtr enter) : enter(enter)
{
}
};
class Flagstone : public Floor
{
public:
/* Select proper overloaded function using casting */
Flagstone() : Floor((enterPtr)(void (Object:: *)(Flagstone *))&Object::Enter)
{
}
};
void Object::Enter(Floor *f)
{
cout << " Generic object enters generic floor" << endl;
}
void Object::Enter(Flagstone *fs)
{
cout << "Generic object enters flagstone" << endl;
}
void Box::Enter(Floor *f)
{
/* Box enters generic floor */
cout << "Box enters generic floor" << endl;
}
void Box::Enter(Flagstone *b)
{
/* Executed when a Box enters Flagstone: Correct */
cout << "Box enters Flagstone" << endl;
}
int main()
{
Floor *f = new Flagstone();
Object *o = new Box();
(o->*(f->enter))(f);
return 0;
}

Answer 1

Could I ask you to provide a minimum, reproducible example? Copying the code as is doesn't compile; indeed, there seems to be a circular dependency between the Floor and Object classes, as both rely on each other's implementation to be defined at all!
Both me and Nathan have tried to resolve this by forward-declaring the derived subtype 'Box', but this might be moot because:
you may want to invoke Box methods from Floor::Enter and Flagstone::Enter
the compiler throws an error for 'an undefined reference to a vtable', with answers here:
I agree with the others that Object::Enter(Flagstone*) seems redundant seems redundant given there exists Object::Enter(Floor*), which can resolve the dynamic type of the pointer passed-in

Answer 2

I ended up just realizing that the main() in this code could be actually a virtual Object or Floor method! Proper method will be called at first place and it will know one of the objects' true class.
So I cleaned the code. The function Enter(Floor *, Item *) just calls virtual method Floor::Enter() and it delegates the control to virtual method Item::Enter(), but now with addition to overloading.
The result method just reacts for the specific Floor and Item for example: Flagstone and Box incrementing the placed boxes counter.
This is very clean solution, however I can't make the methods inline as there is a cycle dependancy. But it's not a problem.
Here is the solution code:
#include <iostream>
using namespace std;
class Floor;
class Flagstone;
class Item
{
public:
/* Overload */
virtual void Enter(Floor *fl)
{
cout << "Item enters Floor." << endl;
}
virtual void Enter(Flagstone *fs)
{
cout << "Item enters Flagstone." << endl;
}
};
class Box : public Item
{
public:
static int count;
virtual void Enter(Floor *fl)
{
cout << "Box enters Floor." << endl;
}
virtual void Enter(Flagstone *fs)
{
cout << "Box enters Flagstone. Count++" << endl;
count++;
}
};
class Cherry : public Item
{
};
class Item;
class Floor
{
public:
/* Virtual Floor method. If object is in derived class,
it will call proper method. */
virtual void Enter(Item *it);
};
class Flagstone : public Floor
{
public:
virtual void Enter(Item *it);
};
class Wall : public Floor
{
};
/* Virtual Floor method. If object is in derived class, it will call proper method. */
void Floor::Enter(Item *it)
{
/* OK, we have Floor and Item or Item sub-class now we call item method, enter */
it->Enter(this);
}
void Flagstone::Enter(Item *it)
{
/* OK, we have Flagstone */
it->Enter(this);
}
int Box::count = 0;
void Enter(Floor *fl, Item *it)
{
fl->Enter(it);
}
int main(void)
{
Floor *fl = new Flagstone;
Item *it = new Box;
Enter(fl, it);
return 0;
}