为指向ctypes结构的指针释放内存时出错？

Question

I am using a C extension module in Python (call it ext) using ctypes to access a C library. I have two ctypes structures, Foo and Bar, which circularly point to one another. Explicitly, Bar holds a ctypes pointer to an instance of Foo, and Foo holds a void pointer (for long reasons) that gets assigned to an instance of Bar, ie

class Foo(Structure):
    _fields_ = [("number", c_int), 
                ("ptr", c_void_p)]

class Bar(Structure):
    _fields_ = [("ptr", POINTER(Foo))]
    def __init__(self, f):
        ext.init(byref(f), byref(self))

f = Foo()
b = Bar(f)

where the C code for ext.init , which assigns the pointers, looks like this:

void init(struct Foo* f, struct Bar* b){
  f->ptr = b;
  b->ptr = f;
}

I can now print number with

print(b.ptr.contents.number)

But if I access this variable a second time, I get this error:

"python(1104,0x7fff75425300) malloc: *** error for object 0x10706b6e0:
 pointer being freed was not allocated"

I believe ctypes always makes a new object whenever you retrieve an attribute, so maybe the problem is that Bar can't release the memory ptr points to since it didn't allocate it? If it makes a difference, Foo and Bar are in different C extensions.

UPDATE

I think I understand things slightly better now. When I call

print(b.ptr.contents.number)

(I think) a new python object is created for b.ptr.contents. Then, when it goes out of scope after the print statement, Foo.__del__ gets called (I'm at least sure of the last part, since I added a print statement in Foo.__del__ ).

Foo.__del__ is set up to call a function in the C library to free all the pointers in the instance (the real struct is more complicated than above).

I don't understand how the object b.ptr.contents gets created. If it doesn't call Foo.__init__ , then the memory for the pointers wouldn't get allocated, so maybe it would make sense that I get the error above?

Answer 1

Thanks @eryksun for solving this for me. In case it's useful to others, the problem was that I had:

class Foo(Structure):
   ...
   def __del__(self):
      ext.free_pointers(byref(self))

where free_pointers was a C function that freed all the pointers in C's Foo struct instance. As eryksun points out, when I access b.ptr.contents , this makes a Foo instance, but it has a member _b_needsfree_ that's set to 0 (so that your original instance in C doesn't get deallocated whenever you access the pointer), so all I had to do to fix the problem, is check this variable, ie,

class Foo(Structure):
   ...
   def __del__(self):
      if self._b_needsfree_ == 1:
         ext.free_pointers(byref(self))