Boost.Python: как вызвать методы super ()?
У меня есть модуль с двумя классами C ++, которые оба имеют метод foo():
struct MyClassA{
void foo() { std::cout << "MyClassA::foo()" << std::endl; }
};
struct MyClassB{
void foo() { std::cout << "MyClassB::foo()" << std::endl; }
};
BOOST_PYTHON_MODULE(my_module){
class_<MyClassA>("MyClassA", init<>()).def("foo", &MyClassA::foo);
class_<MyClassB>("MyClassB", init<>()).def("foo", &MyClassB::foo);
}
В Python я создаю класс, производный от обоих классов:
from my_module import MyClassA, MyClassB
class Derived(MyClassA, MyClassB):
def foo(self):
super().foo() # should be unnessessary - doesn't work anyway
a = MyClassA()
a.foo() # works
b = MyClassB()
b.foo() # works
d = Derived()
d.foo() # only prints 'MyClassA::foo()'
Теперь я хотел бы иметь d.foo() вызов MyClassA.foo() так же как MyClassB.foo(), Но пока Derived.mro() выглядит хорошо:
[<class '__main__.Derived'>, <class 'my_module.MyClassA'>, <class 'my_module.MyClassB'>, <class 'Boost.Python.instance'>, <class 'object'>]
.. только MyClassA.foo() вызывается.
Как сделать так, чтобы методы C ++ вызывали их super() методы? И это работает для __init__() также?
Решение
Слой C ++ не имеет прямого доступа к информации MRO, которую Python использует для автоматизации вызовов суперкласса через super, Если вы загрязнили код C ++ явным знанием Python, вы можете напрямую создать объект PySuper_Type (должен вызываться с двумя аргументами; магия, которая позволяет без аргументов super было бы недоступно) и использовать это, но смешивая код Python с кодом C ++, который сильно уродлив.
На практике лучший совет с Boost.Python, вероятно, так же, как для pybind11 (специальный инструмент C ++ 11 только для заголовков, который служит аналогичной цели, не завися от всей экосистемы Boost), и рекомендуемый подход заключается в явном вызове методов родительского класса уровня C ++, а не в явном виде через super, Просто не существует разумного способа объединить подходы C ++ и Python к множественному наследованию, которые не приводят к безнадежному загрязнению не-Python-кода специальным Python-кодом. pybind11подход будет следующим:
class Derived(MyClassA, MyClassB):
# Must define __init__ even though you only defer to parent classes,
# or only MyClassA will be created
def __init__(self):
MyClassA.__init__(self)
MyClassB.__init__(self)
def foo(self):
MyClassA.foo(self)
MyClassB.foo(self)
Другие решения
Мой текущий подход (адаптировано из этот ответ) нужна какая-то обертка, которая обрабатывает super()Вызовы вручную. Полученные классы больше не нуждаются в специальной обработке:
Код C ++:
struct MyClassA{
void foo() { std::cout << "MyClassA::foo()" << std::endl; }
};
struct MyClassB{
void foo() { std::cout << "MyClassB::foo()" << std::endl; }
};
BOOST_PYTHON_MODULE(my_module){
class_<MyClassA>("MyClassACpp", init<>()).def("foo", &MyClassA::foo);
class_<MyClassB>("MyClassBCpp", init<>()).def("foo", &MyClassB::foo);
}
обертка:
from my_module import MyClassACpp, MyClassBCpp
def call_super(cls, instance, method, *args):
mro = instance.__class__.mro()
for next_class in mro[mro.index(cls) + 1:]:
if not hasattr(next_class, method):
continue
if next_class.__module__ in {'Boost.Python', 'builtins'}:
continue
getattr(next_class, method)(instance, *args)
if next_class.__module__ != 'my_module':
break
class MyClassA(MyClassACpp):
def __init__(self):
call_super(MyClassA, self, '__init__')
print('MyClassA.__init__()')
def foo(self):
call_super(MyClassA, self, 'foo')
class MyClassB(MyClassBCpp):
def __init__(self):
call_super(MyClassB, self, '__init__')
print('MyClassB.__init__()')
def foo(self):
call_super(MyClassB, self, 'foo')
использование:
class Derived(MyClassA, MyClassB):
def foo(self):
super().foo()
d = Derived()
d.foo()
выход:
MyClassA.__init__()
MyClassB.__init__()
MyClassA::foo()
MyClassB::foo()