使用 pybind11 在类方法中调用嵌入函数

我正在开发一个使用 pybind11 嵌入 python 的 C++ 应用程序，在尝试从类方法调用嵌入函数时遇到了一些问题。

首先是我的绑定：

#ifdef _DEBUG
#undef _DEBUG
#include <python.h>
#define _DEBUG
#else
#include <python.h>
#endif
#include <embed.h>

namespace py = pybind11;
using namespace py::literals;

void DebugInfo(std::string string_)
{
    String LogMessage_(string_.c_str());
    LOGINFO(LogMessage_);
}

PYBIND11_EMBEDDED_MODULE(Test, m) {
    m.def("DebugInfo", &DebugInfo, "Posts message to DEBUGINFO");
}

然后我可以有一个 .py 文件：

import Test
test.DebugInfo("I'm a lumberjack and that's OK")

它会打印得很好来调试

当我尝试从类方法中调用它时，麻烦就开始了。

import Test
class PyTest(object):
    def __init__(self):
        test.DebugInfo("I'm a lumberjack and that's OK")

test = PyTest()

当它运行时，它会针对cast.h抛出异常，特别是针对该函数的第1985行：

template <return_value_policy policy>
class unpacking_collector {
public:
    template <typename... Ts>
    explicit unpacking_collector(Ts &&...values) {
        // Tuples aren't (easily) resizable so a list is needed for collection,
        // but the actual function call strictly requires a tuple.
        auto args_list = list();
        int _[] = { 0, (process(args_list, std::forward<Ts>(values)), 0)... };
        ignore_unused(_);

        m_args = std::move(args_list);
    }

    const tuple &args() const & { return m_args; }
    const dict &kwargs() const & { return m_kwargs; }

    tuple args() && { return std::move(m_args); }
    dict kwargs() && { return std::move(m_kwargs); }

    /// Call a Python function and pass the collected arguments
    object call(PyObject *ptr) const {
        PyObject *result = PyObject_Call(ptr, m_args.ptr(), m_kwargs.ptr());
        if (!result)
            throw error_already_set();  //EXCEPTION THROWS HERE!
        return reinterpret_steal<object>(result);
    }

因为这可能与我从主应用程序中调用整个过程的方式相关

//Start the Python Interpreter
py::scoped_interpreter guard{};
//Python variables
py::object thing_;
std::string test_py = Import_File("test.py");
auto locals = py::dict();
py::exec(test_py, py::globals(), locals);
thing_ = locals["test"].cast<py::object>();
thing_.attr("start")();

和 test.py 的内容

import Test
class PyTest(object):
    def __init__(self, message = "Test Object initialized"):
        self.message = message
        iterstr = str(self.iter)
        message = self.message + iterstr
        self.iter = 0
        Test.DebugInfo(message)
    def start(self):
        self.message = "Starting Python Object"
        self.iter = self.iter + 1
        iterstr = str(self.iter)
        message = self.message + iterstr
        Test.DebugInfo(message)
    def update(self):
        self.message = "Python Object Update Cycle:"
        self.iter = self.iter + 1
        iterstr = str(self.iter)
        message = self.message + iterstr
        Test.DebugInfo(message)

test = PyTest()

我不确定我是否遇到了 pybind11 的限制、其中的错误，或者我是否只是把整个事情搞砸了。

任何见解将不胜感激。

这也被作为一个问题提交给pybind11 here: https://github.com/pybind/pybind11/issues/1452 https://github.com/pybind/pybind11/issues/1452

我遇到了这个SO和问题，但我想通了。将其复制到此处，供将来第一个偶然发现此问题的人使用

基本上，你实际上并不想要空白py::dict for locals;它会导致各种各样的问题。如果您查看文档或测试中的嵌入示例代码，localsvalue 总是复制全局范围。

See:

* https://pybind11.readthedocs.io/en/stable/advanced/embedding.html

* https://github.com/pybind/pybind11/blob/master/tests/test_embed/test_interpreter.cpp#L57

您的选择是复制全局范围，或者在这种情况下，只是不传入locals

py::scoped_interpreter guard{}; 
auto globals = py::globals();
py::exec(test_py, globals);
thing_ = globals["Object"].cast<py::object>(); 
thing_.attr("start")();

看起来在顶级代码（不在任何模块内）的情况下，globals变量保存此范围内的值。