PyBind11实现独立编译C++模块通过Python共享不透明指针

核心问题在于：两个独立编译的模块中，同名的SharedClass会被视为完全不同的C++类型（各自拥有独立的类型元信息），直接传递指针会触发PyBind11的类型校验失败。以下是两种简单可行的不透明指针传递方案：

方法一：用void*作为通用指针载体 #

将具体类指针转为void*在Python层中转，两个模块分别完成类型转换，Python无需感知具体类型。

ModuleA 实现代码 #

#include <pybind11/pybind11.h>
namespace py = pybind11;

// 自定义类实现
class SharedClass {
    // 你的类成员与方法
};

class ClassA {
public:
    SharedClass* getSharedClassPointer() {
        return &shared_obj;
    }
private:
    SharedClass shared_obj;
};

PYBIND11_MODULE(ModuleA, m) {
    py::class_<ClassA>(m, "ClassA")
        .def(py::init<>())
        .def("getSharedClassPointer", [](ClassA& a) {
            // 转为void*返回给Python
            return reinterpret_cast<void*>(a.getSharedClassPointer());
        });
}

ModuleB 实现代码 #

#include <pybind11/pybind11.h>
namespace py = pybind11;

// 仅声明类，无需完整定义（仅存指针不调用成员时）
class SharedClass;

class ClassB {
public:
    void setSharedClassPointer(void* ptr) {
        shared_ptr = reinterpret_cast<SharedClass*>(ptr);
    }
private:
    SharedClass* shared_ptr = nullptr;
};

PYBIND11_MODULE(ModuleB, m) {
    py::class_<ClassB>(m, "ClassB")
        .def(py::init<>())
        .def("setSharedClassPointer", [](ClassB& b, void* ptr) {
            b.setSharedClassPointer(ptr);
        });
}

Python 调用代码 #

from ModuleA import ClassA
from ModuleB import ClassB

A = ClassA()
B = ClassB()
B.setSharedClassPointer(A.getSharedClassPointer())

注意：两个模块中SharedClass的内存布局必须完全一致，否则reinterpret_cast会导致未定义行为。

方法二：正确使用PyCapsule传递指针 #

PyCapsule是Python标准库中用于传递不透明指针的容器，比void*多一层类型校验，更安全。

ModuleA 实现代码（封装指针为PyCapsule） #

#include <pybind11/pybind11.h>
#include <Python.h>
namespace py = pybind11;

class SharedClass {
    // 你的类实现
};

class ClassA {
public:
    SharedClass* getSharedClassPointer() {
        return &shared_obj;
    }
private:
    SharedClass shared_obj;
};

// 可选：胶囊销毁函数（本例中SharedClass是ClassA成员，无需手动释放）
void capsule_destroy(PyObject* capsule) {
    void* ptr = PyCapsule_GetPointer(capsule, "SharedClassPointer");
    // 若为动态分配对象，此处需delete ptr;
}

PYBIND11_MODULE(ModuleA, m) {
    py::class_<ClassA>(m, "ClassA")
        .def(py::init<>())
        .def("getSharedClassPointer", [](ClassA& a) {
            void* ptr = a.getSharedClassPointer();
            // 创建带标识的PyCapsule
            return PyCapsule_New(ptr, "SharedClassPointer", capsule_destroy);
        });
}

ModuleB 实现代码（解析PyCapsule） #

#include <pybind11/pybind11.h>
#include <Python.h>
namespace py = pybind11;

class SharedClass;

class ClassB {
public:
    void setSharedClassPointer(SharedClass* ptr) {
        shared_ptr = ptr;
    }
private:
    SharedClass* shared_ptr = nullptr;
};

PYBIND11_MODULE(ModuleB, m) {
    py::class_<ClassB>(m, "ClassB")
        .def(py::init<>())
        .def("setSharedClassPointer", [](ClassB& b, py::object capsule) {
            // 验证胶囊标识并解析指针
            void* ptr = PyCapsule_GetPointer(capsule.ptr(), "SharedClassPointer");
            if (!ptr) {
                throw py::value_error("无效胶囊或指针类型不匹配");
            }
            b.setSharedClassPointer(reinterpret_cast<SharedClass*>(ptr));
        });
}

Python 调用代码 #

from ModuleA import ClassA
from ModuleB import ClassB

A = ClassA()
B = ClassB()
B.setSharedClassPointer(A.getSharedClassPointer())

原方法失败原因说明 #

1. 方法1失败：独立编译模块的SharedClass是不同C++类型，PyBind11生成的Python类型对象不兼容
2. 方法2失败：未手动将指针封装为PyCapsule对象，PyBind11无法直接返回原始指针
3. 方法3失败：PyBind11共享数据机制仅适合同一模块或特定全局共享场景，独立模块间未正确配置会导致空指针

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