我正在寻找一种将 C++ 类实例公开给 python 嵌入式解释器的简单方法。
我想将我的 Foo 的 C++ 世界实例暴露给 python 世界（并被视为 Foo 类）。
这可能吗，如果可以，怎么做？
我认为这几乎就像第一个答案： boost::python::ptr 或 PyInstance_New usage
我想这意味着我应该使用
boost.Python我唯一的目标是在嵌入式 python 解释器中操作我的 Foo 的 C++ 实例（不确定它可以用以前的方法完成）。
事实上，我已经将我的 Foo 类暴露给 python（使用 swig）。
我有什么：
我的 Foo 类：
class Foo{...};
我的包装库（包括 Foo 类）暴露给 python： 这样我就可以启动 python 解释器并做这样的事情：
import my_module
foo=my_modulde.Foo()
我想要的：
拥有一个嵌入 python 解释器并操作 C++ 世界变量的 C++ 主程序。
int main(int argc, char **argv)
{
Foo foo; // instanciates foo
Py_Initialize();
Py_Main(argc, argv); // starts the python interpreter
// and manipulates THE foo instance in it
Py_Finalize();
return 0;
}
Boost python 允许您以非常紧密集成的方式将 c++ 类公开给 python - 您甚至可以包装它们，以便您可以从 c++ 类派生 python 类，并将虚拟方法解析为 python 覆盖。
boost python 教程 是一个很好的起点。
编辑：
您可以创建一个 c++ 对象并将对它的引用传递给内部 python 解释器，如下所示：
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/python.hpp>
#include <string>
#include <iostream>
namespace bp = boost::python;
struct Foo{
Foo(){}
Foo(std::string const& s) : m_string(s){}
void doSomething() {
std::cout << "Foo:" << m_string << std::endl;
}
std::string m_string;
};
typedef boost::shared_ptr<Foo> foo_ptr;
BOOST_PYTHON_MODULE(hello)
{
bp::class_<Foo, foo_ptr>("Foo")
.def("doSomething", &Foo::doSomething)
;
};
int main(int argc, char **argv)
{
Py_Initialize();
try {
PyRun_SimpleString(
"a_foo = None\n"
"\n"
"def setup(a_foo_from_cxx):\n"
" print 'setup called with', a_foo_from_cxx\n"
" global a_foo\n"
" a_foo = a_foo_from_cxx\n"
"\n"
"def run():\n"
" a_foo.doSomething()\n"
"\n"
"print 'main module loaded'\n"
);
foo_ptr a_cxx_foo = boost::make_shared<Foo>("c++");
inithello();
bp::object main = bp::object(bp::handle<>(bp::borrowed(
PyImport_AddModule("__main__")
)));
// pass the reference to a_cxx_foo into python:
bp::object setup_func = main.attr("setup");
setup_func(a_cxx_foo);
// now run the python 'main' function
bp::object run_func = main.attr("run");
run_func();
}
catch (bp::error_already_set) {
PyErr_Print();
}
Py_Finalize();
return 0;
}
作为参考，以下是使用 pybind11 实现此目的的方法：
#include <iostream>
#include <pybind11/pybind11.h>
namespace py = pybind11;
// Define C++ class "Foo"
class Foo {
std::string s_;
public:
Foo(const std::string &s) : s_(s) {}
void doSomething() { std::cout << s_ << std::endl; }
};
typedef std::shared_ptr<Foo> FooPtr;
// Define Python module "bar" and Python class "bar.Foo" wrapping the C++ class
PYBIND11_MODULE(bar, m) {
py::class_<Foo, FooPtr>(m, "Foo")
.def("doSomething", &Foo::doSomething);
}
int main(int argc, char **argv)
{
// Create a C++ instance of Foo
FooPtr foo = std::make_shared<Foo>("Hello, World!");
// Initialize Python interpreter and import bar module
PyImport_AppendInittab("bar", PyInit_bar);
Py_Initialize();
PyRun_SimpleString("import bar");
// Make C++ instance accessible in Python as a variable named "foo"
py::module main = py::module::import("__main__");
main.attr("foo") = foo;
// Run some Python code using foo
PyRun_SimpleString("foo.doSomething()");
// Finalize the Python interpreter
Py_Finalize();
return 0;
}
我知道这是一个老问题，但这里有一个使用 SWIG 的解决方案。
foo.h:
#pragma once
#include <string>
struct Foo{
Foo();
Foo(std::string const& s);
void doSomething();
std::string m_string;
};
foo.cpp:
#include "foo.h"
#include <iostream>
Foo::Foo() {}
Foo::Foo(std::string const& s) : m_string(s) {}
void Foo::doSomething() {
std::cout << "Foo:" << m_string << std::endl;
}
foo.i:
%module module
%{
#include "foo.h"
%}
%include "std_string.i"
%include "foo.h"
与运行时一起生成常用的 SWIG 包装器
swig -python -c++ -Wall foo.i
swig -python -c++ -Wall -external-runtime runtime.h
生成包含
struct Foog++ -fPIC -Wall -Wextra -shared -o _module.so foo_wrap.cxx foo.cpp -I/usr/include/python2.7 -lpython2.7
如果你想在多个模块之间共享类型信息，可以添加一个参数
-DSWIG_TYPE_TABLE=SomeName现在，这是
Foo#include "foo.h"
#include <Python.h>
#include "runtime.h"
int main(int argc, char **argv) {
Py_Initialize();
PyObject* syspath = PySys_GetObject((char*)"path");
PyObject* pName = PyString_FromString((char*) ".");
int err = PyList_Insert(syspath, 0, pName);
Py_DECREF(pName);
err = PySys_SetObject((char*) "path", syspath);
PyObject *main, *module, *pInstance, *run, *setup;
try {
main = PyImport_ImportModule("__main__");
err = PyRun_SimpleString(
"a_foo = None\n"
"\n"
"def setup(a_foo_from_cxx):\n"
" print 'setup called with', a_foo_from_cxx\n"
" global a_foo\n"
" a_foo = a_foo_from_cxx\n"
"\n"
"def run():\n"
" a_foo.doSomething()\n"
"\n"
"print 'main module loaded'\n");
// Load Python module
module = PyImport_ImportModule("module");
swig_type_info *pTypeInfo = nullptr;
pTypeInfo = SWIG_TypeQuery("Foo *");
Foo* pFoo = new Foo("Hello");
int owned = 1;
pInstance =
SWIG_NewPointerObj(reinterpret_cast<void*>(pFoo), pTypeInfo, owned);
setup = PyObject_GetAttrString(main, "setup");
PyObject* result = PyObject_CallFunctionObjArgs(setup, pInstance, NULL);
Py_DECREF(result);
run = PyObject_GetAttrString(main, "run");
result = PyObject_CallFunctionObjArgs(run, NULL);
Py_DECREF(result);
}
catch (...) {
PyErr_Print();
}
Py_DECREF(run);
Py_DECREF(setup);
Py_DECREF(pInstance);
Py_DECREF(module);
Py_DECREF(main);
Py_Finalize();
return 0;
}
以上内容可以通过以下方式编译：
g++ -Wall -Wextra -I/usr/include/python2.7 main.cpp foo.cpp -o main -lpython2.7
2023答案
pybind11 似乎让这一切变得非常简单，他们有一个特殊的头文件用于使用 pybind 进行嵌入和一些详细的文档：
https://pybind11.readthedocs.io/en/stable/advanced/embedding.html
pybind11 是一个只有头文件的库，所以这是跨平台的，不会添加额外的依赖项（python 解释器除外）
这里是解决原帖问题的代码：
#include <pybind11/embed.h>
#include <iostream>
struct Foo{
Foo(const std::string & s) : m_string(s){}
void doSomething() {
std::cout << "Foo:" << m_string << std::endl;
}
std::string m_string;
};
typedef std::shared_ptr<Foo> FooPtr;
namespace py = pybind11;
PYBIND11_EMBEDDED_MODULE(bar, m) {
py::class_<Foo, FooPtr>(m, "Foo")
.def("doSomething", &Foo::doSomething);
}
int main(int argc, char **argv)
{
py::scoped_interpreter guard{};
FooPtr foo = std::make_shared<Foo>("Hello, World!");
py::module::import("bar");
py::module main = py::module::import("__main__");
main.attr("foo") = foo;
// Run some Python code using foo
py::exec("foo.doSomething()");
}