libcpp | Embedded Systems C Library Support

It should be clearly described this way:

• myclass.pyx is compiled into .so file
• But there are 2 kinds of stuff in a .so file
  • Python definitions: Can be imported only with 'import'
  • Cython definitions: Can be imported only with 'cimport'

The problem is import myclass in another.pxd won't import myclass because it is cdef (Cython definition).

In another.pxd file, to import 'myclass', it must be either:

• from myclass cimport myclass
  • myvar2 will be: cdef myclass myvar2
• cimport myclass
  • myvar2 will be: cdef myclass.myclass myvar2
• cimport some.path.to.myclass as myclass
  • myvar2 will be: cdef myclass myvar2

There may be a problem with exporting too, especially using Python build tool instead of cython3 and gcc directly:

• __pyx_capi__ is not available in the .so file
• myclass is not public and aren't seen after importing

Thus better put the myclass under public scope in myclass.pyx:

I've tried to search and alter the code but these are the only ways:

• Use .hpp header
• Or use 'sorted' function of Python

No C++ closure syntax in Cython as per my internet search, use struct with operator overload instead.

As mentioned in the comments, your desired constructor is not available inside Cython. AFAIK, Cython doesn't support templated constructors yet. As a workaround, you could use .assign(), i.e.:

I have not tried Cyton, but std::shared_ptr has an static cast function std::static_pointer_cast. I think this will work

I've resolved this problem. The issue here was not about host linkopts with protoc/protobuf, but with another library (gflags) that used -lpthread unconditionally. Adding the same android config and select statement used by protobuf fixed this issue (PR). The red herring about using a non-existent -lnotareallibrary was a linker error for protoc, not my target executable.

In case it's helpful to describe the debugging process, I searched the autogenerated bazel-myreponame/external directory's BUILD files and .bzl files for -lpthread. (At first, I only thought to search BUILD files, which missed this library)

Oops... just remove new.

Like, malloc, C++'s new allocates memory and returns a pointer to it. Here want actually want to reference the object directly.

Because C++ supports function overloading, function names are "mangled" during the compilation process so that they have unique names in the object file. Using extern "C" prevents that mangling from happening.

If you leave out extern "C" when compiling, then call_c_function is expecting to call a C++ function with the name add, in particular the mangled name would be _Z3addii. Since add exists in a .c file it has the unmangled name instead of the mangled name, so now _Z3addii is considered an external function just like printf, and like all other external functions they are expected to be resolved at link time of the executable, not compile time, and not when the static library is created.

When you create a static library, you're not actually linking. You're just grouping several object files together into a larger archive. That way, when linking actually happens, you only need to link a single file instead of multiple.

There are two parts to Cython's wrapping of types such as std:: vector:

1. The .pxd files it defines for your to cimport (e.g. https://github.com/cython/cython/blob/master/Cython/Includes/libcpp/vector.pxd). These are provided for your convenience (to save everyone the effort of re-writing the same files). They use standard Cython syntax and you can create similar files to wrap other classes.

2. The auto-conversion to/from Python types documented here. This is built in to Cython and you cannot apply it to other types that you wrap. This should not prevent you from creating a usable wrapping though - you may just need to copy a little more data manually at the Python/C++ interface.

Wrapping std::array in Cython is a bit challenging since Cython cannot readily handle numeric template arguments. There are a variety of tricks to persuade it to work that you can find on Stack Overflow and elsewhere (Interfacing C++11 array with Cython, Wrapping std::array in Cython and Exposing it to memory views) but none of them are great.

Here are my experience with installing kivy:

• Make sure you don't use python version 3.9
• pip install kivy - does not work

create new project using Virtualenv and using python 3.7 (of course other versions can also work except 3.9)

then simply create requirements.txt file within root of your project if not yet exist and include kivy

Pycharm automatically asks if you want to install requirements.

Finally, verify