使用自定义holder类型的pybind11多继承无法转换为基类类型

这个问题我之前也碰到过！当用自定义holder代替pybind11默认的智能指针时，多继承的向上转型确实不会自动工作——因为pybind11只默认处理unique_ptr/shared_ptr这类标准智能指针的多继承转换逻辑，自定义holder需要我们手动给它搭好转型的桥梁。

下面是具体的解决步骤和代码示例，帮你搞定这个问题：

核心问题拆解 #

pybind11需要明确知道：如何把持有派生类C的自定义holder，转换成持有基类A或B的holder。我们有两种常见的实现方式，选哪种取决于你的自定义holder结构：

方式1：给自定义holder添加转换构造函数 #

如果你的自定义holder是模板类，最简单的方式是给它加一个模板构造函数，支持从派生类的holder转换到基类的holder。比如我们定义一个简单的MyHolder：

#include <pybind11/pybind11.h>
#include <memory>
#include <type_traits>

namespace py = pybind11;

// 纯抽象基类A
class A {
public:
    virtual void foo() = 0;
    virtual ~A() = default;
};

// 纯抽象基类B
class B {
public:
    virtual void bar() = 0;
    virtual ~B() = default;
};

// 派生类C，多继承A和B
class C : public A, public B {
public:
    void foo() override {}
    void bar() override {}
};

// 自定义holder模板类
template <typename T>
class MyHolder {
public:
    // 默认构造、原始指针构造
    MyHolder() = default;
    explicit MyHolder(T* ptr) : m_ptr(ptr) {}

    // 关键：添加从派生类holder转换到基类holder的模板构造函数
    template <typename U, typename = std::enable_if_t<std::is_base_of_v<T, U>>>
    MyHolder(const MyHolder<U>& other) : m_ptr(other.get()) {}

    // 必须提供get()方法，pybind11需要用它获取原始指针
    T* get() const { return m_ptr.get(); }
    T& operator*() const { return *m_ptr; }
    T* operator->() const { return m_ptr.get(); }

    void reset(T* ptr = nullptr) { m_ptr.reset(ptr); }

private:
    std::unique_ptr<T> m_ptr; // 这里用unique_ptr做内部管理，你可以换成自己的内存逻辑
};

接下来是绑定代码，注意要给每个基类指定对应的holder类型，派生类要同时声明所有基类和自身的holder：

PYBIND11_MODULE(multi_inherit_holder, m) {
    // 绑定基类A，指定holder为MyHolder<A>
    py::class_<A, MyHolder<A>>(m, "A")
        .def("foo", &A::foo);

    // 绑定基类B，指定holder为MyHolder<B>
    py::class_<B, MyHolder<B>>(m, "B")
        .def("bar", &B::bar);

    // 绑定派生类C，列出所有基类A、B，同时指定holder为MyHolder<C>
    py::class_<C, A, B, MyHolder<C>>(m, "C")
        .def(py::init<>());
}

方式2：特化pybind11的holder_helper模板 #

如果你的自定义holder没办法添加转换构造函数（比如不是模板类，或者有特殊的内存管理逻辑），可以通过特化pybind11内部的holder_helper模板来告诉它如何转换：

在绑定代码之前添加这段特化：

namespace pybind11 {
namespace detail {
    // 特化holder_helper，处理MyHolder<U>到MyHolder<T>的转换（U是T的派生类）
    template <typename T, typename U>
    struct holder_helper<MyHolder<T>, MyHolder<U>> {
        static MyHolder<T> convert(const MyHolder<U>& src) {
            // 这里根据你的holder逻辑实现转换，比如返回一个持有src.get()的MyHolder<T>
            return MyHolder<T>(src.get());
        }
    };
} // namespace detail
} // namespace pybind11

绑定代码和方式1完全一样，这样pybind11就知道怎么把MyHolder<C>转换成MyHolder<A>或MyHolder<B>了。

测试Python代码 #

现在你在Python里就可以正常做向上转型了：

import multi_inherit_holder

c = multi_inherit_holder.C()
# 可以把C实例赋值给A类型的变量
a = multi_inherit_holder.A(c)
a.foo()

# 也可以赋值给B类型的变量
b = multi_inherit_holder.B(c)
b.bar()

关键注意点 #

• 自定义holder必须提供get()方法，pybind11需要通过它获取原始的C++对象指针。
• 绑定基类时一定要指定对应的holder类型，否则pybind11会用默认的holder（通常是unique_ptr），导致类型不匹配。
• 派生类的绑定必须列出所有直接基类，pybind11需要这个信息来构建类型层次结构。

内容的提问来源于stack exchange，提问作者Gabor Varga