
Cppyy – Automatic Python-C++ bindings - d3k
https://cppyy.readthedocs.io/en/latest/index.html
======
kazinator
How does this know the difference between:

    
    
      const char *cls::func(void)
      {
         return "abc"; // static: caller must not free
      }
    

and

    
    
      const char *cls::func(void)
      {
         return strdup("abc"); // caller must free
      }
    

Edit: I see: _designed for large scale programs in high performance computing
that use modern C++._

Modern C++ meaning, no pointers anywhere.

~~~
progval
It looks like this gives you a `ctypes` pointer:
[https://cppyy.readthedocs.io/en/latest/basic_types.html#poin...](https://cppyy.readthedocs.io/en/latest/basic_types.html#pointers)

So you handle it like any other ctypes pointer, ie. `libc =
ctypes.CDLL(find_library("c")); libc.free(ptr)`

Which is not fun in Python. So yeah, better avoid raw pointers.

------
malkia
There is also the less known
[https://github.com/google/clif](https://github.com/google/clif) (but not
automatic)

------
backslash_16
From the comments below, it sounds like interfacing my C++ code with python
using Cppyy would sacrifice performance.

Even so this will be awesome for unit testing. I really like the testing
interface pytest provides, along with its parametrized tests.

Anyone else using python to test the logic their C/C++ code? I can't think of
how I would test the memory allocation and freeing portion. Anyone think it's
a bad idea?

~~~
rightbyte
The fuzz converting data types back and forth is probably not worth it.

But one can test the interface to the program nicely from python (i.e. text or
socket i/o).

------
gshulegaard
This is super interesting but if I am looking to bring C++ into my Python code
base it would be because performance is important enough to do so. With that
in mind I am not sure how this stacks up against compiled half steps like
Cython or foreign function interfaces likes ctypes or CFFI instead.

~~~
carlsonmark
If you have a Python code base and are looking to speed up some part of it,
Cython is the way to go. Pybind11 and cppyy are more for cases where you have
a bunch of C++ code that you want to provide a Python interface for.

~~~
ris
Cython unfortunately doesn't have a very good pypy story, which cppyy does.

------
jrussino
I need to create Python bindings for a C++ library and after a brief survey of
the available options was planning on using SWIG
([http://www.swig.org/tutorial.html](http://www.swig.org/tutorial.html)). How
does this compare?

~~~
mochomocha
SWIG is not always smooth to use, and you need to write interface files
manually which in my experience are hard to debug. In Cppyy it looks like you
don't have to do any of that.

------
hatred
Does anyone know of any well known tools that generate bindings in other
languages e.g., Python from C++ code?

IIUC, this tool does the opposite i.e., generate C++/other language bindings
from Python

~~~
dangerbird2
The entirety of cpython’s runtime is exposed as a C api, so you can easily
manipulate python objects in c or any language with a ffi. boost::python
provides a c++ wrapper for cpython, which can be used to call both c/c++ in
python and vice versa

------
corysama
> PyPy 5.7 and 5.8 have a built-in module cppyy.

Nice.

------
adenner
How does this compare to pybind11?

~~~
carlsonmark
If you have a C++ project, you want to have Python bindings, and you don't
want to share your header files, pybind11 is the way to go.

If you want to / can share your header files, cppyy is a very convenient way
of being able to call your C++ code from Python. I'm not sure if there is a
way to use it without headers.

~~~
rightbyte
How do you link any cpp binary without headers without guessing the calling
convention?

~~~
carlsonmark
It's not so much that you never have the headers... more that you don't always
want to provide the headers to everyone (since they may contain things you
don't want to share.)

I looked into it a bit further, and cppyy does have provisions for this:
[https://cppyy.readthedocs.io/en/latest/bindings_generation.h...](https://cppyy.readthedocs.io/en/latest/bindings_generation.html)

I may have misread that page, but it looks like you can create a .rootmap and
.pcm file and distribute that instead of the C++ headers.

------
ttul
Google PyInline

~~~
ttul
[http://pyinline.sourceforge.net/](http://pyinline.sourceforge.net/)

2001 vintage

