Re: boost::shared_ptr and multiple inheritance
EnsGabe wrote:
Suppose you have a class heirarchy as such:
class Base{
...
};
class Mid1 : public Base{
...
};
class Mid2 : public Base{
...
};
class Derived: public Mid1, Mid2{
};
Mid1, Mid2, and Base are ABC.
What is an effective way to manage the lifetime of this object?
Currently, I leak Derived (and anything similar to Derived) all over
the place by not reclaiming them at all. That works for now, in as
much as when I am done with them I am done with execution of my
program, but is not a solution that will work for the future.
My use at the moment is as such:
class ObjectHolder {
public:
...
void addMid1(Mid1 *p) { assert(p); mid1s.push_back(p); };
void addMid2(Mid2 *p) { assert(p); mid2s.push_back(p); };
private:
std::vector<Mid1*> mid1s;
std::vector<Mid2*> mid2s;
...
};
There will be many different classes that are equivalent to Derived
(in the sense that they are deriving from Mid1 and Mid2.) There will
also be classes that derive from one or the other of Mid1 and Mid2.
All of them will be registered exactly once in mid1s and/or mid2s,
whichever they are derived from. References to the objects will not
exist outside of ObjectHolder. Objects may contain references to
other objects; the directed graph that they form will be acyclic.
My first instinct was to delete every element of mid1s and mid2s in
the destructor for ObjectHolder, but that will not work when a Derived
has been inserted into both vectors.
The following is based on the idea that the objects should unregister
themselves upon destruction.
#include <set>
#include <iostream>
class Owner;
class BaseA {
Owner * owner_ptr;
public:
virtual
~BaseA ( void );
void register_owner ( Owner * p );
};
class BaseB {
Owner * owner_ptr;
public:
virtual
~BaseB ( void );
void register_owner ( Owner * p );
};
class Owner {
std::set< BaseA * > all_a;
std::set< BaseB * > all_b;
public:
void register_a ( BaseA * p ) {
all_a.insert( p );
p->register_owner( this );
}
void register_b ( BaseB * p ) {
all_b.insert( p );
p->register_owner( this );
}
void unregister_a ( BaseA * p ) {
all_a.erase( p );
}
void unregister_b ( BaseB * p ) {
all_b.erase( p );
}
~Owner ( void ) {
while ( ! all_a.empty() ) {
std::set< BaseA * >::iterator first = all_a.begin();
BaseA * a_ptr = *first;
all_a.erase( first );
delete a_ptr;
}
while ( ! all_b.empty() ) {
std::set< BaseB * >::iterator first = all_b.begin();
BaseB * b_ptr = *first;
all_b.erase( first );
delete b_ptr;
}
}
};
BaseA::~BaseA ( void ) {
owner_ptr->unregister_a( this );
std::cout << "a";
}
void BaseA::register_owner ( Owner * p ) {
owner_ptr = p;
}
BaseB::~BaseB ( void ) {
owner_ptr->unregister_b( this );
}
void BaseB::register_owner ( Owner * p ) {
owner_ptr = p;
std::cout << "b";
}
class X : public BaseA, public BaseB {
virtual
~X ( void ) {
std::cout << "x";
}
};
int main ( void ) {
Owner o;
for ( unsigned int i = 0; i < 10; ++i ) {
X * x = new X;
o.register_a( x );
o.register_b( x );
BaseA * a = new BaseA;
o.register_a( a );
BaseB * b = new BaseB;
o.register_b( b );
}
}
My next idea was to use
boost::shared_ptr and use that to automatically manage the lifetime of
the object, but there was nothing in the documentation that I saw that
led me to believe that one could use a shared_ptr across a class
heirarchy. Since the 'this' pointer for an object is different
depending on the type it is being used as, I'm (possibly erroneously)
assuming that a shared_ptr will mismanage the reference count for the
pointer since they are using different pointers. Am I wrong in my
understanding of the semantics of boost::shared_ptr?
[snip]
If D is derived from T, then tr1::shared_ptr<T> allows assignment and copy
construction from tr1::shared_ptr<D>. So, if you do:
std::vector< shared_ptr<Mid1> > mid1s;
std::vector< shared_ptr<Mid2> > mid2s;
and
void addMid1 ( shared_ptr<Mid1> p );
void addMid2 ( shared_ptr<Mid2> p );
you can use it as follows:
shared_ptr< Derived > d_ptr = new Derived ( ... );
addMid1( d_ptr );
addMid2( d_ptr );
and it should work just fine. Have you tried?
Best
Kai-Uwe Bux