我怎样才能实现一个C++ Python 中的类，由 C++ 调用？

Question

我有一个用 C++ 编写的类接口。我有一些实现这个接口的类也是用 C++ 编写的。这些在较大的 C++ 程序的上下文中调用，该程序本质上实现了“main”。我希望能够在 Python 中编写此接口的实现，并允许它们在更大的 C++ 程序的上下文中使用，就像它们刚刚用 C++ 编写一样。

关于 python 和 C++ 的接口已经有很多文章了，但我不太清楚如何做我想做的事情。我能找到的最接近的是这里：http://www.cs .brown.edu/~jwicks/boost/libs/python/doc/tutorial/doc/html/python/exusing.html#python.class_virtual_functions，但这不太正确。

更具体地说，假设我有一个现有的 C++ 接口，定义如下：

// myif.h
class myif {
   public:
     virtual float myfunc(float a);
};

我想要做的事情是：

// mycl.py
... some magic python stuff ...
class MyCl(myif):
  def myfunc(a):
    return a*2

然后，回到我的 C++ 代码中，我希望能够这样说：

// mymain.cc
void main(...) {
  ... some magic c++ stuff ...
  myif c = MyCl();  // get the python class
  cout << c.myfunc(5) << endl;  // should print 10
}

我希望这是足够清楚；）

Answer 1

这个答案有两个部分。首先，您需要以允许 Python 实现随意覆盖部分接口的方式在 Python 中公开接口。然后你需要展示你的 C++ 程序（在 main 中如何调用 Python）。

---

向 Python 公开现有接口：

第一部分使用 SWIG 很容易完成。我稍微修改了你的示例场景来修复一些问题并添加了一个额外的测试函数：

// myif.h
class myif {
   public:
     virtual float myfunc(float a) = 0;
};

inline void runCode(myif *inst) {
  std::cout << inst->myfunc(5) << std::endl;
}

现在我将在不将 Python 嵌入到您的应用程序中的情况下查看问题，即您在 Python 中启动 excetion，而不是在 C++ 中的 int main() 中。稍后添加相当简单不过，

首先要跨语言多态性工作：

%module(directors="1") module

// We need to include myif.h in the SWIG generated C++ file
%{
#include <iostream>
#include "myif.h"
%}

// Enable cross-language polymorphism in the SWIG wrapper. 
// It's pretty slow so not enable by default
%feature("director") myif;

// Tell swig to wrap everything in myif.h
%include "myif.h"

为此，我们启用了 SWIG不过，其余部分是非常标准的 SWIG

实现：

import module

class MyCl(module.myif):
  def __init__(self):
    module.myif.__init__(self)
  def myfunc(self,a):
    return a*2.0

cl = MyCl()

print cl.myfunc(100.0)

module.runCode(cl)

然后我就可以编译并运行它：

swig -python  -c++ -Wall myif.i 
g++ -Wall -Wextra -shared -o _module.so myif_wrap.cxx -I/usr/include/python2.7 -lpython2.7

python mycl.py 
200.0
10

正是您希望从该测试中看到的内容。

---

嵌入Python在应用程序中：

接下来我们需要实现 mymain.cc 的真实版本，我已经整理了它的外观草图：

#include <iostream>
#include "myif.h"
#include <Python.h>

int main()
{
  Py_Initialize();

  const double input = 5.0;

  PyObject *main = PyImport_AddModule("__main__");
  PyObject *dict = PyModule_GetDict(main);
  PySys_SetPath(".");
  PyObject *module = PyImport_Import(PyString_FromString("mycl"));
  PyModule_AddObject(main, "mycl", module);

  PyObject *instance = PyRun_String("mycl.MyCl()", Py_eval_input, dict, dict);
  PyObject *result = PyObject_CallMethod(instance, "myfunc", (char *)"(O)" ,PyFloat_FromDouble(input));

  PyObject *error = PyErr_Occurred();
  if (error) {
    std::cerr << "Error occured in PyRun_String" << std::endl;
    PyErr_Print();
  }

  double ret = PyFloat_AsDouble(result);
  std::cout << ret << std::endl;

  Py_Finalize();
  return 0;
}

它基本上只是标准的 将 Python 嵌入到另一个应用程序。它的工作原理并给出了您希望看到的内容：

g++ -Wall -Wextra -I/usr/include/python2.7 main.cc -o main -lpython2.7
./main
200.0
10
10

---

难题的最后一部分是能够将您在 Python 中创建实例时获得的 PyObject* 转换为 myif *。 SWIG 再次使这变得相当简单。

首先，我们需要要求 SWIG 在头文件中为我们公开其运行时。我们通过额外调用 SWIG 来完成此操作：

swig -Wall -c++ -python -external-runtime runtime.h

接下来，我们需要重新编译 SWIG 模块，显式给出 SWIG 知道的类型表的名称，以便我们可以从 main.cc 中查找它。我们使用以下方法重新编译 .so：

g++ -DSWIG_TYPE_TABLE=myif -Wall -Wextra -shared -o _module.so myif_wrap.cxx -I/usr/include/python2.7 -lpython2.7

然后，我们在 main.cc 中添加一个辅助函数，用于将 PyObject* 转换为 myif*：

#include "runtime.h"
// runtime.h was generated by SWIG for us with the second call we made

myif *python2interface(PyObject *obj) {
  void *argp1 = 0;
  swig_type_info * pTypeInfo = SWIG_TypeQuery("myif *");

  const int res = SWIG_ConvertPtr(obj, &argp1,pTypeInfo, 0);
  if (!SWIG_IsOK(res)) {
    abort();
  }
  return reinterpret_cast<myif*>(argp1);
}

现在，我们可以使用它了从 main() 内部：

int main()
{
  Py_Initialize();

  const double input = 5.5;

  PySys_SetPath(".");
  PyObject *module = PyImport_ImportModule("mycl");

  PyObject *cls = PyObject_GetAttrString(module, "MyCl");
  PyObject *instance = PyObject_CallFunctionObjArgs(cls, NULL);

  myif *inst = python2interface(instance);
  std::cout << inst->myfunc(input) << std::endl;

  Py_XDECREF(instance);
  Py_XDECREF(cls);

  Py_Finalize();
  return 0;
}

最后我们必须使用 -DSWIG_TYPE_TABLE=myif 编译 main.cc，这给出：

./main
11

Answer 2

最小的例子；请注意，Base 不是纯虚拟的，这一事实使情况变得复杂。我们开始：

1. baz.cpp：

   <前><代码>#include<字符串>
   #include
   使用 std::string ；
   命名空间 py=boost::python;

   结构基数{
   虚拟字符串 foo() const { return "Base.foo"; }
   // fooBase 是非虚拟的，可以从任何地方调用它（c++ 或 python）
   // 将通过c++调度
   字符串 fooBase() const { 返回 foo(); }
   };
   struct BaseWrapper: Base, py::wrapper{
   字符串 foo() 常量{
   // 如果 Base 是抽象的（在 python 中不可实例化），那么
   // 这里只有 this->get_override("foo")()
   //
   // 如果在 python 中调用覆盖 foo 的类
   if(this->get_override("foo")) 返回 this->get_override("foo")();
   // python 中没有覆盖；如果直接实例化 Base(Wrapper) 就会发生
   否则返回 Base::foo();
   }
   };

   BOOST_PYTHON_MODULE（巴兹）{
   py::class_("Base")
   .def("foo",&Base::foo)
   .def("fooBase",&Base::fooBase)
   ;
   }
   

2. bar.py

   导入系统
   sys.path.append('.')
   导入巴兹
   
   类 PyDerived(baz.Base):
     def foo(self): 返回 'PyDerived.foo'
   
   基=baz.Base()
   der=PyDerived()
   打印base.foo(),base.fooBase()
   打印 der.foo(), der.fooBase()
   

3. Makefile

   <前><代码>默认：
   g++ -shared -fPIC -o baz.so baz.cpp -lboost_python `pkg-config python --cflags`

结果是：

Base.foo Base.foo
PyDerived.foo PyDerived.foo

您可以在其中看到 fooBase() （非虚拟 C++ 函数）如何调用虚拟 foo()，无论是在 C++ 还是 Python 中，都会解析为覆盖。你可以在 C++ 中从 Base 派生一个类，它的工作原理是一样的。

编辑（提取c++对象）：

PyObject* obj; // given
py::object pyObj(obj); // wrap as boost::python object (cheap)
py::extract<Base> ex(pyObj); 
if(ex.check()){ // types are compatible
  Base& b=ex(); // get the wrapped object
  // ...
} else {
  // error
}

// shorter, thrwos when conversion not possible
Base &b=py::extract<Base>(py::object(obj))();

从PyObject*构造py::object并使用py::extract查询 python 对象是否与您尝试提取的内容匹配：PyObject* obj; py::extract<基础>提取器（py::对象（obj））； if(!extractor.check()) /* 错误 */;基地& b=提取器();

Answer 3

引用 http://wiki.python.org/moin/boost.python/Inheritance

“Boost.Python 还允许我们表示 C++ 继承关系，以便可以传递包装的派生类，其中值、指针或对基类的引用需要作为参数。”

有一些虚函数的示例，可以解决第一部分（带有类 MyCl(myif) 的部分）

对于执行此操作的具体示例，http://wiki.python.org/moin/boost.python/OverridableVirtualFunctions

对于 myif c = MyCl(); 行你需要将你的Python（模块）暴露给C++。这里有一些例子 http://wiki.python.org/moin/boost.python/EmbeddingPython

Answer 4

基于Eudoxos的（非常有帮助的）答案我已经采用了他的代码并扩展了它，现在有一个嵌入式解释器，带有内置模块。

这个答案在 Boost.Python 中相当于我基于 SWIG 的答案。

头文件 myif.h：

class myif {
public:
  virtual float myfunc(float a) const { return 0; }
  virtual ~myif() {}
};

基本上与问题中一样，但具有 myfunc 的默认实现和虚拟析构函数。

对于Python实现，MyCl.py我基本上与问题相同：

import myif

class MyCl(myif.myif):
  def myfunc(self,a): 
    return a*2.0

然后剩下mymain.cc，其中大部分基于Eudoxos的答案：

#include <boost/python.hpp>
#include <iostream>
#include "myif.h"

using namespace boost::python;

// This is basically Eudoxos's answer:
struct MyIfWrapper: myif, wrapper<myif>{
  float myfunc(float a) const {
    if(this->get_override("myfunc")) 
      return this->get_override("myfunc")(a);
    else 
      return myif::myfunc(a);
  }
};

BOOST_PYTHON_MODULE(myif){
  class_<MyIfWrapper,boost::noncopyable>("myif")
    .def("myfunc",&myif::myfunc)
  ;
}
// End answer by Eudoxos

int main( int argc, char ** argv ) {
  try {
    // Tell python that "myif" is a built-in module
    PyImport_AppendInittab("myif", initmyif);
    // Set up embedded Python interpreter:
    Py_Initialize();

    object main_module = import("__main__");
    object main_namespace = main_module.attr("__dict__");

    PySys_SetPath(".");
    main_namespace["mycl"] = import("mycl");

    // Create the Python object with an eval()
    object obj = eval("mycl.MyCl()", main_namespace);

    // Find the base C++ type for the Python object (from Eudoxos)
    const myif &b=extract<myif>(obj)();
    std::cout << b.myfunc(5) << std::endl;

  } catch( error_already_set ) {
    PyErr_Print();
  }
}

我在这里添加的关键部分，高于“如何使用 Boost.Python 嵌入 Python？”以及“如何使用 Boost.python 扩展 Python？” （由 Eudoxos 回答）是“我如何在同一个程序中同时执行这两个操作？”这个问题的答案。解决这个问题的方法在于 PyImport_AppendInittab call，它采用通常在加载模块时调用的初始化函数并将其注册为内置模块。因此，当 mycl.py 说 import myif 时，它最终会导入内置的 Boost.Python 模块。

Answer 5

看一下 Boost Python，它是连接 C++ 和 Python 的最通用、最强大的工具。

http://www.boost.org/doc/libs/1_48_0/库/python/doc/

Answer 6

没有真正的方法可以将 C++ 代码直接与 Python 连接。

SWIG 确实可以处理这个问题，但它构建了自己的包装器。

相对于 SWIG，我更喜欢的一种替代方案是 ctypes，但要使用它，您需要创建一个 C 包装器。

例如：

// myif.h
class myif {
   public:
     virtual float myfunc(float a);
};

像这样构建一个 C 包装器：

extern "C" __declspec(dllexport) float myif_myfunc(myif* m, float a) {
    return m->myfunc(a);
}

由于您使用 C++ 进行构建，因此 extern“C” 允许 C 链接，因此您可以从 dll 轻松调用它，并且 __declspec(dllexport) 允许从dll。

在 Python 中：

from ctypes import *
from os.path import dirname

dlldir = dirname(__file__)                      # this strips it to the directory only
dlldir.replace( '\\', '\\\\' )                  # Replaces \ with \\ in dlldir
lib = cdll.LoadLibrary(dlldir+'\\myif.dll')     # Loads from the full path to your module.

# Just an alias for the void pointer for your class
c_myif = c_void_p

# This tells Python how to interpret the return type and arguments
lib.myif_myfunc.argtypes = [ c_myif, c_float ]
lib.myif_myfunc.restype  = c_float

class MyCl(myif):
    def __init__:
        # Assume you wrapped a constructor for myif in C
        self.obj = lib.myif_newmyif(None)

    def myfunc(a):
        return lib.myif_myfunc(self.obj, a)

虽然 SWIG 为您完成了所有这些工作，但您几乎没有空间可以随意修改内容，而不会因重新生成 SWIG 包装器时必须重做的所有更改而感到沮丧。

ctypes 的一个问题是它不处理 STL 结构，因为它是为 C 设计的。SWIG 确实为您处理了这个问题，但您也许可以自己将其包装在 C 中。这取决于您。

这是 ctypes 的 Python 文档：

http://docs.python.org/library/ctypes.html< /a>

此外，构建的 dll 应该与 Python 接口位于同一文件夹中（为什么不呢？）。

不过我很好奇，为什么要从 C++ 内部调用 Python，而不是直接调用 C++ 实现？