Hello, I have a use case where a polymorphism factory can instantiate object of a non exposed class. I have a multi-level inheritance scheme and the last level is not exposed to Python. What I try to understand is why the Python object of the last level takes the type of the top-most class in the inheritance hierarchy and not the one just above?
Here is a minimal example to reproduce the behavior:
C++ side
class Base
{
public:
Base() {}
virtual ~Base() = default;
};
class Derived: public Base
{
public:
Derived(int value) { m_value = value; }
~Derived() = default;
int getValue() { return m_value; }
private:
int m_value;
};
class DerivedTwo: public Derived
{
public:
DerivedTwo(int value): Derived(value) {}
~DerivedTwo() = default;
};
std::shared_ptr<Base> factory()
{
return std::make_shared<Derived>(9);
}
std::shared_ptr<Base> factoryTwo()
{
return std::make_shared<DerivedTwo>(99);
}
BOOST_PYTHON_MODULE(mymodule)
{
using namespace boost::python;
class_<Base, std::shared_ptr<Base>, boost::noncopyable>("Base", init<>());
class_<Derived, bases<Base>, std::shared_ptr<Derived>, boost::noncopyable>("Derived", init<int>())
.def("get_value", &Derived::getValue)
;
def("factory", &factory);
def("factory_two", &factoryTwo);
}
Hello, I have a use case where a polymorphism factory can instantiate object of a non exposed class. I have a multi-level inheritance scheme and the last level is not exposed to Python. What I try to understand is why the Python object of the last level takes the type of the top-most class in the inheritance hierarchy and not the one just above?
Here is a minimal example to reproduce the behavior:
C++ side
Python side
Output
Obviously, if I expose DerivedTwo class, all is OK. Thanks for your help.