Re: boost::shared_ptr and multiple inheritance

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 );
  }

}

If D is derived from T, then tr1::shared_ptr<T> allows assignment and cop=

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