Unexpected virtual dispatch behavior when passing subclass instance to function via pointer

[larsmunaf]

Hi,

I'm running into what seems like unexpected behavior in nanobind regarding virtual dispatch.

I have two C++ classes, a base class Shape and a subclass Circle, each with their own draw() method:

struct Shape {
    virtual void draw(void){ std::cout << "Shape" << std::endl; };
};

struct Circle : public Shape {
    void draw(void) { std::cout << "Circle" << std::endl; } override;
};

I also have a function that takes a std::shared_ptr<Shape> and calls draw():

void call(std::shared_ptr<Shape> shape){
    shape->draw();
}

Bindings look like this:

NB_MODULE(_bindings, m) {
    m.def("create_circle", []() {
        return std::make_shared<Circle>();
    });

    m.def("call", &call);

    nb::class_<Shape>(m, "Shape")
        .def("draw", &Shape::draw);

    nb::class_<Circle, Shape>(m, "Circle")
        .def("draw", &Circle::draw);
}

Now, from Python:

shape = create_circle()
shape.draw() # Outputs: "Circle"
call(shape)       # Outputs: "Shape"

This suggests that dynamic dispatch is lost when the object is passed back into C++. I also tested with raw pointers and the behaviour remains the same, i.e., Shape::draw() gets called in call().

Is there something I am missing in how nanobind handles dynamic type information for subclass instances passed into C++ functions?

Thanks four your help!

[wjakob]

Cannot reproduce. I get

Circle
Circle

Did you test your own C++ code? This does not even compile on my end, I had to change it to

struct Shape {
    virtual void draw(void){ std::cout << "Shape" << std::endl; };
    virtual ~Shape() = default;
};

struct Circle : public Shape {
    void draw(void) override { std::cout << "Circle" << std::endl; };
};

void call(std::shared_ptr<Shape> shape){
    shape->draw();
}

What I suspect is happening without knowning all details is that you are returning some other class, e.g. HyperCircle derived from Circle. And you are not exposing bindings for HyperCircle. Then, you are surprised that you get a Shape instead of at least a Circle which would be closer in the class hierarchy. That is a limitation of C++ and typeid() upon which all this dynamic casting relies. Nanobind cannot walk up/down the class hierarchy to give you the closest type.

Either you get the type declared on the function interface, or the derived type if it has bindings.

[larsmunaf]

Yes, that's on me, sorry about that. My actual bindings are more complex, which is why I tried to provide a simple toy example. If there is no conceptual error in the toy example, the issue lies within my full bindings.

Now that I am more confident that this should work, I can better track down the issue and will report back.

Thanks for your help!

[larsmunaf]

Found the issue. I overlooked a third-party library call was slicing the std::shared_ptr<Shape> passed to call(). This made it seem as if the problem was in my bindings at first. Sorry about the confusion, closing this now.