Pybind11绑定C++抽象类（DLL接口）

本文为李你干嘛原创，转载请注明出处：Pybind11绑定C++抽象类（DLL接口）

摘要

假设我们将DLL中的接口封装成了C++抽象类，并将该类和DLL文件提供给用户，类似于抽象类导出DLL中描述的办法，如果这个时候我们想使用pybind11绑定这个C++抽象类，会遇到报错，如抽象类无法实例化等等，此时Pybind11给出了辅助类的办法overriding-virtual-functions-in-python，但是如果只想转换C++抽象类的一部分的话，这个方案是不适用的。Pybind11有个很强大的功能，如果我们将C++类使用py::class绑定后，那么C++暴露给python的这个类会自动转换成Python的类。如果我们要大量的在Python中使用到这个C++抽象类且接触不到其基类时，就没有办法完成这个抽象类的绑定。
在这里我们给出一个解决思路，即用Wrapper类将C++的抽象类封装，并对这个类使用pybind绑定，这样我们就有了一个Python端的Wrapper类。再根据官网给出的办法Custom Type Casters实现从Python端Wrapper类到C++抽象类和从C++抽象类到Python端Wrapper类的自动转换。这样当C++暴露给Python这个抽象类时，pybind会自动调用转换器将抽象类转换成Wrapper类的Python对象，当Python的Wrapper类传递给C++时，会将Wrapper类变成C++抽象类。
问题描述

假设我们将C++抽象类AbstractDLLInterface作为DLL接口，ConcreteDLLInterface1类作为具体实现，但是并不把它暴露给用户。

1. #ifdef MYDLL_EXPORTS
2. #define MYDLL_API __declspec(dllexport)
3. #else
4. #define MYDLL_API __declspec(dllimport)
5. #endif
7. // 抽象类接口
8. class MYDLL_API AbstractDLLInterface {
9. public:
10.     virtual ~AbstractDLLInterface() {}
11.     virtual void dllFunction() = 0;
12.     virtual AbstractDLLInterface* createInstance() const = 0;
13. };
15. // 具体的实现类1
16. class ConcreteDLLInterface1 : public AbstractDLLInterface {
17. public:
18.     void dllFunction() override;
19.     AbstractDLLInterface* createInstance() const override;
20. };
22. // 在实现文件中提供具体实现
23. void ConcreteDLLInterface1::dllFunction() {
24.     // DLL 接口函数的具体实现
25.     // ...
26. }
28. AbstractDLLInterface* ConcreteDLLInterface1::createInstance() const {
29.     return new ConcreteDLLInterface1();
30. }

复制代码

现在我们只有AbstractDLLInterface类的声明和一个DLL文件，我们的C++代码中需要经常使用AbstractDLLInterface类作为返回值或者函数参数，而我们需要把这一部分用Pybind绑定。下面给出解决方案。
解决方案

创建Wrapper类

1. class Wrapper {
2. public:
3.     Wrapper(AbstractDLLInterface* instance) : instance_(instance) {}
5.     void dllFunction() {
6.         instance_->dllFunction();
7.     }
9.     AbstractDLLInterface* instance_;
10. };

复制代码

定义AbstractDLLInterface类的type_caster

1. namespace PYBIND11_NAMESPACE {
2.     namespace detail {
3.         template <> struct type_caster<AbstractDLLInterface> {
4.         public:
6.             PYBIND11_TYPE_CASTER(AbstractDLLInterface, const_name("AbstractDLLInterface"));
8.             /**
9.              * Conversion part 1 (Python -> C++): convert a PyObject into an AbstractDLLInterface
10.                          */
11.             bool load(handle src, bool) {
12.                 Wrapper wrapper = py::cast<Wrapper>(src);
13.                 value = *(wrapper.instance_);
14.                 return true;
15.             }
17.             /**
18.              * Conversion part 2 (C++ -> Python): convert an AbstractDLLInterface into a PyObject
19.              */
20.             static handle cast(AbstractDLLInterface src, return_value_policy policy, handle parent) {
21.                 std::shared_ptr<Wrapper> wrapper_ptr = std::make_shared<Wrapper>(&src);
22.                 return type_caster<std::shared_ptr<Wrapper>>::cast(wrapper_ptr, py::return_value_policy::take_ownership, parent);
23.             }
24.         };
25.     }
26. } // namespace PYBIND11_NAMESPACE::detail

复制代码

Pybind中的处理思路无非是在绑定好的类、函数上，在python遇到定义过的类或者类型等就将其从C++的类包装成python的类，在python端有参数要传递给C++就将参数从Python类转换成C++类。上面的代码就实现了这个过程，我们将Python中的Wrapper类与C++中的AbstractDLLInterface类视为等效的，那么如果有Python中的Wrapper类需要传入到C++中时，会调用load将AbstractDLLInterface类实例从Wrapper类中提取出来，如果C++中有AbstractDLLInterface类实例要传入到Python中时，会调用cast新建一个Wrapper实例，再将这个Wrapper实例转换成Python对象传入到Python空间中。
实际操作用大多数不会用到AbstractDLLInterface而是AbstractDLLInterface的智能指针，此处是对AbstractDLLInterface进行转换，但是处于安全性考虑最好对std::shared_ptr类型进行转换。
绑定Pybind

1. // 绑定代码
2. PYBIND11_MODULE(my_module, m) {
3.     py::class_<Wrapper, std::shared_ptr<Wrapper>>(m, "Wrapper")
4.         .def(py::init<AbstractDLLInterface*>())
5.         .def("dllFunction", &Wrapper::dllFunction);
6. }

复制代码

注意此时我们不需要绑定AbstractDLLInterface类，绑定AbstractDLLInterface类编译时会报错。py::class_传入参数Wrapper, std::shared_ptr可以保证
本文为李你干嘛原创，转载请注明出处：Pybind11绑定C++抽象类（DLL接口）


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！