Zeljko Vrba [zvrba@ifi.uio.no] wrote:

He might just allocate the shared_ptr on the heap (the dynamic memory allocation will be anyway cheaper than thread creation):

void *thread(void *ptr) { shared_ptr<X> *_p = static_cast(ptr); shared_ptr<X> p = *_p; delete _p; ... }

void creator() { ... pthread_create(&thrid, 0, thread, new shared_ptr<X>(orig_ptr)); ... }

No need for any additional synchronization.

Good point. And certainly much simpler than my solution.

Elli Barasch wrote:

Shared pointer question: [snip odd example]

Will this cause a memory leak? Do I need to do a delete in between, or does the act of reassignment cause the prior object to be dereferenced?

A second assignment to a given shared_ptr should not cause a leak. You should avoid an explicit delete. If p is a shared_ptr pointing to a heap object, then assigning a new value to p will decrement the previously-referenced object's refcount, which may cause the heap object to be deleted. This document: http://boost.org/libs/smart_ptr/shared_ptr.htm#Members says this under 'assignment': shared_ptr & operator=(shared_ptr const & r); // never throws template<class Y> shared_ptr & operator=(shared_ptr<Y> const & r); // never throws template<class Y> shared_ptr & operator=(std::auto_ptr<Y> & r); Effects: Equivalent to shared_ptr(r).swap(*this). Returns: *this. Notes: The use count updates caused by the temporary object construction and destruction are not considered observable side effects, and the implementation is free to meet the effects (and the implied guarantees) via different means, without creating a temporary. But the important point is that the assignment must behave as though a shared_ptr holding p's prior value has been deleted.

Thank you two for the help. On 12/18/07, Zeljko Vrba wrote:

On Tue, Dec 18, 2007 at 10:28:37AM -0500, Andrew Holden wrote: He might just allocate the shared_ptr on the heap (the dynamic memory allocation will be anyway cheaper than thread creation):

void *thread(void *ptr) { shared_ptr<X> *_p = static_cast(ptr); shared_ptr<X> p = *_p; delete _p; ... }

void creator() { ... pthread_create(&thrid, 0, thread, new shared_ptr<X>(orig_ptr)); ... }

Ok. This is how my code structure looks: ---------------------------- typedef shared_ptr<MyClass> pMyClass; void* MyClass::actionThread(void *objectPointer) { pMyClass * _obj = static_cast(objectPointer); pMyClass obj = *_obj; obj->action(false); delete _obj; } void MyClass::action(bool threaded) { if (threaded) { pthread_t tid; pthread_create(&tid, 0, actionThread, new pMyClass(this)) } else { //TODO: actually perform the action } } ---------------------------- When calling an instance->action(false) it works correctly. When calling instance->action(true) it sometimes segfaults. So i'm not sure i interpreted your code sample correctly. Do i need to use enable_shared_from_this? Or do i have to avoid using "this" (orig_ptr in your code) somehow maybe? Thanks in advance! -- Saludos, Bruno González _______________________________________________ Msn/Jabber: stenyak AT gmail.com ICQ: 153709484 http://www.stenyak.com

STenyaK (Bruno Gonzalez) [stenyak@gmail.com] wrote:

Ok. This is how my code structure looks: ---------------------------- typedef shared_ptr<MyClass> pMyClass; void* MyClass::actionThread(void *objectPointer) { pMyClass * _obj = static_cast(objectPointer); pMyClass obj = *_obj; obj->action(false); delete _obj; } void MyClass::action(bool threaded) { if (threaded) { pthread_t tid; pthread_create(&tid, 0, actionThread, new pMyClass(this)) } else { //TODO: actually perform the action } } ---------------------------- When calling an instance->action(false) it works correctly. When calling instance->action(true) it sometimes segfaults. So i'm not sure i interpreted your code sample correctly.

Do i need to use enable_shared_from_this? Or do i have to avoid using "this" (orig_ptr in your code) somehow maybe?

Thanks in advance!

I would stongly recommend shared_from_this. You code, as written, will guaranteee that actionThread will destroy the MyClass as soon asactionThread finishes, even if the main thread still expects it to exist. This would result in a double-free if the main thread has its own shared pointer to the object. Actually, the fact that this is a member function opens another possibility. First, derive MyClass from enable_shared_from_this <MyClass>, then you can implement the functions like this: ---------------------------- typedef shared_ptr<MyClass> pMyClass; void* MyClass::actionThread(void *objectPointer) { MyClass * _obj = static_cast(objectPointer); pMyClass obj = _obj->shared_from_this(); obj->action(false); } void MyClass::action(bool threaded) { if (threaded) { pthread_t tid; pthread_create(&tid, 0, actionThread, this) } else { //TODO: actually perform the action } } ---------------------------- This works because shared_from_this is specifically designed to allow member functions of a class to recover the shared pointer to the object.

STenyaK (Bruno Gonzalez) [stenyak@gmail.com] wrote:

On 12/19/07, Andrew Holden wrote:

...

typedef shared_ptr<MyClass> pMyClass; void* MyClass::actionThread(void *objectPointer) { MyClass * _obj = static_cast(objectPointer); pMyClass obj = _obj->shared_from_this(); obj->action(false); }

void MyClass::action(bool threaded) { if (threaded) { pthread_t tid; pthread_create(&tid, 0, actionThread, this) } else { //TODO: actually perform the action } } ----------------------------

This works because shared_from_this is specifically designed to allow member functions of a class to recover the shared pointer to the object.

Just in case... actionThread is a static method of the class, since otherwise C++ won't allow me to get a pointer of it (and i dislike global functions). Does this fact have any implications in the last proposed code sample?

Not really. actionThread is still a member function of MyClass, which means it has full access to MyClass's members (as long as it has access to a MyClass object somehow), including private and protected members, and protected members from base classes. _obj is a valid pointer to a MyClass, so there is nothing wrong with actionThread calling _obj's shared_from_this function.

Andrew Holden [aholden@charteroaksystems.com] wrote:

STenyaK (Bruno Gonzalez) [stenyak@gmail.com] wrote:

...

Ok. This is how my code structure looks: ---------------------------- typedef shared_ptr<MyClass> pMyClass; void* MyClass::actionThread(void *objectPointer) { pMyClass * _obj = static_cast(objectPointer); pMyClass obj = *_obj; obj->action(false); delete _obj; } void MyClass::action(bool threaded) { if (threaded) { pthread_t tid; pthread_create(&tid, 0, actionThread, new pMyClass(this)) } else { //TODO: actually perform the action } } ----------------------------

---------------------------- typedef shared_ptr<MyClass> pMyClass; void* MyClass::actionThread(void *objectPointer) { MyClass * _obj = static_cast(objectPointer); pMyClass obj = _obj->shared_from_this(); obj->action(false); }

void MyClass::action(bool threaded) { if (threaded) { pthread_t tid; pthread_create(&tid, 0, actionThread, this) } else { //TODO: actually perform the action } } ----------------------------

I just realized you should ignore this implementation because it contains a race condition (main thread may delete the object before actionThread can call shared_from_this. Here is a tweak for your version that uses shared_from_this: ---------------------------- typedef shared_ptr<MyClass> pMyClass; void* MyClass::actionThread(void *objectPointer) { pMyClass * _obj = static_cast(objectPointer); pMyClass obj = *_obj; delete _obj; obj->action(false); } void MyClass::action(bool threaded) { if (threaded) { pthread_t tid; //Change next line: pthread_create(&tid, 0, actionThread, new pMyClass(shared_from_this())) } else { //TODO: actually perform the action } } ----------------------------