将指向连续数据的指针从 Python 传递到 C 的最简单方法

Question

I am using ctypes to call function in C . Function expects pointer to the first element of the contiguous data and number of data.

One thing that works is something like that

a=15 # a could be any number
temp = numpy.array([a]*14, dtype=numpy.int8)
c_function(temp.ctypes.data_as(ctypes.c_void_p), 14)

This is really cumbersome, requires both numpy and ctypes . Is there any other more simple way that works both in Python2 and Python3 (AFAIK bytes([a]*14) works but only for Python3)

EDIT: More interestingly this also works (!)

a=15 # a could be any number
temp = chr(a)*14
c_function(temp, 14)

There were suggestions in other threads that one could pass something pointer to the first element of the contiguous data, like here Passing memoryview to C function , but I was just unable to make this work.

Answer 1

Preliminaries

Python does not have pointers. You cannot create a pointer in Python, though Python variables act in some ways like pointers. You can create Python objects that represent lower-level pointers, but what you actually seem to want is to feed your C function a pointer to Python-managed data, which is an altogether different thing.

What ctypes does for you

You seem to have settled on using ctypes for the actual function call, so the general question expressed in the question title is a little overbroad for what you actually want to know. The real question seems to be more like "How do I get ctypes to pass a C pointer to Python-managed data to a C function?"

According to the ctypes Python 2 docs , in Python 2,

None , integers, longs, byte strings and unicode strings are the only native Python objects that can directly be used as parameters in these function calls. None is passed as a C NULL pointer, byte strings and unicode strings are passed as pointer to the memory block that contains their data ( char * or wchar_t * ). [...]

(emphasis added).

It's more or less the same list in Python 3 ...

None , integers, bytes objects and (unicode) strings

... with the same semantics.

Note well that ctypes takes care of the conversion from Python object to corresponding C representation -- nowhere does Python code handle C pointers per se , nor even direct representations of them.

Relevant C details

In many C implementations, all object pointer types have the same representation and can be used semi-interchangeably, but pointers of type char * are guaranteed by the standard to have the same size and representation as pointers of type void * . These two pointer types are guranteed to be interchangeable as function parameters and return values, among other things.

Synthesis

How convenient! It is acceptable to call your C function with a first argument of type char * when the function declares that parameter to be of type void * , and that is exactly what ctypes will arrange for you when the Python argument is a byte string (Python 2) or a bytes object (Python 3). The C function will receive a pointer to the object's data, not to the object itself. This provides a simpler and better way forward than going through numpy or a similar package, and it is basically the approach that you appended to your question. Thus, supposing that c_function identifies a ctypes-wrapped C function, you could do this (python3):

len = 15
c_function(b'0' * len, len)

Of course, you can also create a variable for the object and pass that, instead, which would allow you to afterward see whatever the C function has done with the contents of the object.

Do note, however, that

1. Byte strings and bytes objects are immutable as far as Python is concerned. You can get yourself in trouble if you use a C function to change the contents of a bytes object that other Python code assumes will never change.

2. The C side cannot determine the size of the data from a pointer to it. That is presumably the purpose of the second parameter. If you tell the function that the object is larger than it really is, and the function relies on that to try to modify bytes past the end of the actual data, then you will have difficult to debug trouble, from corruption of other data to memory leaks. If you're lucky, your program will crash.

3. It depends on what Python implementation you use, but typically the elements of a Unicode string are larger than one byte each. Save yourself some trouble and use byte strings / bytes instead.