Hi folks, new to Boost Python and struggling to build a prototype at
work. I thought I'd start with a conceptual question to help clarify
my understanding. I already have a basic prototype working nicely but
I'm having a few issues, which I may post about later.
A brief functional rundown of what I'm trying to prototype. Hopefully
my explanation doesn't get too confusing!
I'm embedding a python module into an application; Python will provide
application logic, responding to events such as timers expiring or the
user clicking widgets.
I have the following classes I'm exporting to Python:
Entity, DerivedEntity, EntityList (contains pointers to Entity).
They all have varying types of copy/constructors, e.g. some are
private, some have non-const copy constructors etc. It's inherited
code that I can't mess with so I'm stuck with it.
So the typical logic flow I'm looking at is:
C++ Application:
- Create an instance of EntityList called entity_list, populate with
many instances of DerivedEntity.
- Create an instance of EntityList called change_list
- Invoke python function passing entity_list and change_list as
parameters
Python:
- For each entity in entity_list:
- Invoke C++ function clone_entity, pass entity as parameter
C++ Application:
- Create clone of entity like this --> DerivedEntity* entity_copy
= new DerivedEntity(entity)
- return entity_copy to Python
Back in Python again:
- Apply logic to entity_copy returned from clone_entity C++
function
- If entity_copy updated add to change_list
Back in C++ Application:
- For each new_entity in change_list
- Apply further logic to new_entity
- Delete new_entity pointer
- Clear the change_list
I'm having problems in my prototype - it looks like I have a memory
leak but I'm not sure where. So my question is, what should I be aware
of in this logic flow with regards to object ownership and lifetime?
When I receive entity_copy in Python, returned from clone_entity, what
happens to this object when I insert it into change_list and
subsequently delete the C++ pointer? I don't know how to prove that
the Python object is being deleted and isn't hanging around due to a
lifetime issue,
I guess my main problem is that I'm entirely sure I understand object
ownership - who owns what object when it's created in C++, passed to
Python and then returned back to C++ to be deleted.
So if any of this makes sense, I would greatly appreciated any
suggestions or help. I'm very impressed with Boost Python so far but
my own lack of understanding is holding me back I think.
Thanks again
Mike
--
http://mail.python.org/mailman/listinfo/python-list
