C struct in Python

Question

There is a libx.so which export 2 functions, and a struct,

typedef struct Tag {
    int num;
    char *name;
}Tag;

Tag *create(int n, char *n)
{
    Tag *t = malloc(sizeof(Tag));
    t->num = n;
    t->name = n;
    return t;
}

void use(Tag *t)
{
    printf("%d, %s\n", t->num, t->name);
}

I want to call create in Python and then save the Tag *res returned by create, later I will call use and pass the Tag *res saved before to use, here is it (just to demonstrate):

>>>libx = ctypes.CDLL("./libx.so")
>>>res = libx.create(c_int(1), c_char_p("a"))
>>>libx.use(res)

The above code might be wrong, just to demonstrate what I want to do.

And my problem is that, how could I save the result returned by create? Because it returns a pointer to a user-defined struct, and I don't want to construct struct Tag's counterpart in Python, would c_void_p do the trick?

UPDATE

From @David's answer, I still don't quite understand one thing:

the pointer (c_char_p("a")) is only valid for the duration of the call to create. As soon as create returns then that pointer is no longer valid.

And I assign c_char_p("a") to t->name in create, when the call to create finishes, is t->name a dangling pointer? Because according to the quoted words, that pointer is no longer valid after create. Why c_char_p("a") is no longer valid?

David Heffernan · Accepted Answer · 2012-02-24 13:43:23Z

4

+50

The C code that you present is simply not going to work. You need to be much more precise about which party allocates and is responsible for the heap memory.

In your current example you pass c_char_p("a") to the C code. However, the pointer to that ctypes memory is only valid for the duration of the call to create. As soon as create returns then that pointer is no longer valid. But you took a copy of the pointer inside create. Thus the subsequent call to use is liable to fail.

You are going to need to take a copy of the contents of that string and store it in the struct. If you do that then you can use libx.create.restype = c_void_p safely.

But if you want the memory you allocated to be deallocated you will have to provide a destroy function to match the create function. With these changes the C code would look like this:

Tag *create(int n, char *s)
{
    Tag *t = malloc(sizeof(Tag));
    t->num = n;
    t->name = strdup(s);
    return t;
}

void destroy(Tag *t)
{
    free(t->name);
    free(t);
}

The Python code would look like this:

libx = ctypes.CDLL("./libx.so")
libx.create.restype = c_void_p
res = libx.create(c_int(1), c_char_p("a"))
libx.use(res)
libx.destroy(res)

answered Feb 24, 2012 at 13:43

David Heffernan

616k46 gold badges1.1k silver badges1.5k bronze badges

Sign up to request clarification or add additional context in comments.

18 Comments

Thomas Eding Over a year ago

i just went stinky in my pants

Alcott Over a year ago

Well, sir, there are 3 things I don't understand. 1, the pointer to that ctypes memory is only valid for the duration of the call to create. Why is that? I presume it's because after the call to create, c_char_p("a")'s ref-count goes to zero, so "a" is garbage-collected, right? 2, in your code, res is a c_void_p object, but libx.use takes a Tag * arg, can I just pass res directly to libx.use without any cast? 3, why should I explicitly destroy(res)?

David Heffernan Over a year ago

1. Because that's all that ctypes marshalling guarantees. 2. For the purpose of marshalling, a pointer is just a pointer. If you never dereference it, you don't need to know the structure of it. This is opaque pointer pattern. 3. How else are you going to deallocate the memory.

David Heffernan Over a year ago

If your code works then that's just by chance. Heaps are like that. Memory that has been freed is often still accessible and valid. So you can get lucky, but the luck usually runs out at some point.

Alcott Over a year ago

I accept your answers to 2,3. But I don't quite understand the ctypes marshalling, how does it explain 1? Do I presume wrong about it (garbage-collection theory)?

|

wildplasser · Accepted Answer · 2012-02-24 14:05:41Z

0

Python does reference counting. You'll have to use Py_INCREF() and friends for objects that are returned from "external" libraries.

UPDATE: I don't know about .so loading by python, maybe the method proposed by @David Hefferman does this automagically.

UPDATE2: delete me!

edited Feb 24, 2012 at 14:05

answered Feb 24, 2012 at 13:48

wildplasser

44.5k9 gold badges72 silver badges116 bronze badges

1 Comment

David Heffernan Over a year ago

The question concerns ctypes which is a foreign function interface, akin to pinvoke if you know that. Py_INCREF is simply not pertinent.

Collectives™ on Stack Overflow

C struct in Python

2 Answers 2

18 Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

18 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related