From: Jarrad Waterloo (jwaterloo_at_[hidden])
Date: 2007-04-10 13:04:29
I am very interested in such a family of smart pointers as I deeply believe
that weak_ptr isn't a real solution to cyclical references as your scenario
Some questions if you don't mind.
Will resources be cleaned up in a deterministic manner ie. When the last
master of A or B is deleted on the stack will it immediately cleanup A and
B? If that is not the case, is there a gc_cleanup() method that would have
to be called in code or in a background thread?
Can it handle object graphs of arbitrary/any complexity or does it only work
Please don't keep me, the boost user community, waiting.
From: boost-bounces_at_[hidden] [mailto:boost-bounces_at_[hidden]]
On Behalf Of Ariane van der Steldt
Sent: Tuesday, April 10, 2007 1:35 AM
Subject: [boost] interest poll: smart pointers that handle
I was wondering if there's interest in a smart pointer, which is able to
cope with circular references. I think it would make a nice addition to
the smart_ptr classes already in boost.
I have a library almost ready, which can solve the problem where:
- class A contains a pointer to class B
- class B contains a pointer to class A
- and it is not known wether the "master" of these two is A or B.
With "master", I mean which pointer is the pointer that is kept alive
from the execution thread. For example, if we would implement this with
shared_ptr and weak_ptr, we would most likely have the following:
- class A contains a shared_ptr to class B
- class B contains a weak_ptr to class A
- the execution thread contains a shared_ptr Ptr to class A.
In this case, if I where to assign Ptr = B, A would be erased, since A
no longer is referenced (weak_ptr references don't count
The code I have aims to solve this problem, by using two types of
pointers. The execution thread will work with boost::intrusive_ptr
(which are allocated on the stack) while classes wishing to point to
other classes, will use a new type of pointer (named 'reference') that I
designed. This pointer is aware of the owner of the pointer, in addition
of the object it points to.
The implementation uses only standard C++ code, with some help from
boost (notably boost::intrusive_ptr and, in the case of multithreading
Anyways, I am wondering if people are interested. :) Can't imagine that
it wouldn't be of use to at least some of you. ;)
For status info: I am currently ironing out some minor bugs and
implementing STL-type collection classes (like the equivalent of a
std::list<MyClass*> ) for these pointers, as they have non-standard
Unsubscribe & other changes:
Boost list run by bdawes at acm.org, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk