在C ++程序中调用Cython（Python3.6）

Question

I'm working on a project where I need to embed some python code in C++. I've been trying Cython for a while, but I still have a lot of questions. Here's a demo that I have tried.

Here I have a couple files with struct and functions:

First, this is file cat.pyx

cdef public struct Cat:
    int num

cdef public setCatNum(Cat* cat):
    cat.num = 100

cdef public int getCatNum(Cat* cat):
    return cat.num

And its .pxd file cat.pxd :

cdef public struct Cat:
    int num

cdef public setCatNum(Cat* )
cdef public int getCatNum(Cat* )

And this is my setup.py :

from distutils.extension import Extension
from Cython.Distutils import build_ext

ext_modules = [
    Extension("cat", ["cat.pyx"], include_dirs=['.']),
    ]

setup(
  name='dotest',
  cmdclass={'build_ext': build_ext},
  ext_modules=ext_modules,
  script_args=['build_ext'],
  options={'build_ext':{'inplace':True, 'force':True}}
)

It could compile correctly, but in the generated cat.h file, the function declarations are something else:

__PYX_EXTERN_C PyObject *__pyx_f_3cat_setCatNum(struct Cat *); __PYX_EXTERN_C int __pyx_f_3cat_getCatNum(struct Cat *);

So how could I call those functions in my C/C++ program? Thank you in advance.

Answer 1

I'm not sure why it's generating mangled names for the public functions - it runs contrary to the documentation . However it's also doing it for me. I suspect this is a bug, but suggest for the moment you should just use the mangled names.

You probably want to set the return type of setCatNum to void . Currently it returns a PyObject* (always None ) which isn't useful, and means you have to handle its reference count.

cdef public void setCatNum(Cat* )

The thing I think you're getting confused by is the difference between Python 2 and 3. The documentation suggests replacing init<modulename> with

err = PyImport_AppendInittab("modulename", PyInit_modulename);
Py_Initialize();
modulename_module = PyImport_ImportModule("modulename");

That's the only change you need to make - you don't actually need to use the module object.

A working example:

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

int main() {

    auto err = PyImport_AppendInittab("cat", PyInit_cat);
    if (err) {
        std::cout << "ERROR!\n";
        return 1;

    }
    Py_Initialize();
    auto cat_module = PyImport_ImportModule("cat"); // you don't actually have to do anything with this module object
    Cat c;
    __pyx_f_3cat_setCatNum(&c);
    std::cout << __pyx_f_3cat_getCatNum(&c) << "\n";
    Py_Finalize();
}

compiles successfully on Linux with

g++ example_cpp.cpp -o example `python3-config --includes --libs` ./cat.cpython-36m-x86_64-linux-gnu.so

(You may have to change the exact cat filename)

Answer 2

The normal cython development pattern is quite the opposite - you would use it to call C++ code from python, instead.

A simple description of cython common usage is "Write your code in high-level python-like language and it gets converted to C source code for a python extension"

The generated C code is not readable, and not meant to be used from C.

tl;dr Use cython to make your C/C++ program callable from python, and write python code to call it.