Best way to deal with an object that can't be instantiated?

Following your link I see that createBody

b2Body does not return, but a pointer to one:

 b2Body* b2World::CreateBody  ( const b2BodyDef*  def );     

      

        
        
        
      

    

This is probably due to the fact that b2World

• manages the lifetime of b2Body (i.e. removes it and the memory it uses when B2World goes out of scope / itself is removed) or

• Since B2Wsorld needs to support pointers to b2Bodies for example. to iterate over them to accomplish some of the functionality of B2World.

I also note that all it takes (except b2World

) to create b2Body

is a pointer to b2BodyDef

.

So, if you want b2Body not tied to b2World, but can be tied to one later, why not go through b2BodyDefs or pointers to them?

I could create a thin wrapper for b2BodyDef, for example:

 class b2BodyDefWrapper {
   public const b2BodyDef& b2bodyDef;
   public b2BodyDefWrapper( const b2BodyDef& bodydef ) : b2bodyDef(bodydef) {}
   public const b2Body* reifyOn( b2World& world) const { 
     return world.CreateBody( b2bodyDef ) ;
   }
 }

      

        
        
        
      

    

Note that I could attach this b2BodyDefWrapper to multiple worlds or to the same world more than once.

Now it may be that you can do something with b2Body that you cannot do with b2BodyDef and therefore traversing the (possibly wrapped) b2BodyDefs is not suitable for your purposes. In this case, I can use the Command Pattern to "attach" a list of functions to b2BodyDefWrapper

that will "play" on each reified b2Body:

 class b2BodyDefWrapper {
   private std::vector<Command&> commandStack;
   public const b2BodyDef& b2bodyDef;
   public b2BodyDefWrapper( const b2BodyDef& bodydef ) : b2bodyDef(bodydef) {}
   public const b2Body* reify( b2World& world) const { 
     b2body* ret = world.CreateBody( &b2bodyDef ) ;
     for (int i=0; i< commandStack.size(); i++) {
        v[i].applyTo( ret ) ;
     }
     return ret;
   }

   public void addCommand( const Command& command ) {
      commandStack.push_back( command );
   }
 }

      

        
        
        
      

    

Where Command

is the abstract base class for functors, for example:

  class Command {
     virtual ~Command() {}
     virtual void applyTo( b2Body* body ) = 0 ;
  }

      

        
        
        
      

    

with specific subclasses:

 class ApplyForce : public Command {
   private const b2Vec2& force;
   private const b2Vec2& point;
   ApplyForce(const b2Vec2& f, const b2Vec2& p) : force(f), point(p) {}
   virtual void applyTo( b2Body* body ) {
      body->ApplyForce( force, point ) ;
   }
 }

      

        
        
        
      

    

Then I could use my wrapper like this:

extern b2BodyDef& makeb2BodyDef();
b2BodyDefWrapper w( makeb2BodyDef()  ) ; 
ApplyForce a( ..., ... );
w.addCommand( a ) ;
...
b2World myworld;
b2World hisWorld;
w.reifyOn( myWorld ) ;
w.reifyOn( hisWorld) ;

      

        
        
        
      

    

Please note that I am not covering some details, mainly about object ownership and memory management, and who calls delete in CommandStacks; I also didn't follow the three-fold rule in my class sketches. You can fill them in as you like.

I also left any condition for calls from Command, b2Body functions that return non-void and return these values; you can probably cover this (if you need to) if ApplyTo returns some kind of union.

More fundamentally, I haven't talked about how one particular Command can provide its return value (if any) to another specific Command. The complete solution would be to not have Vector of Commands, but an n-ary tree of them, where the child commands are applied first and their return values ​​(if any) are passed to their parent command. If you want that kind of complexity, this is a question I obviously cannot answer. (And I have already given a rather detailed answer, considering that I am not getting paid to do this, and I am not getting the reputation as you, the Wiki'd Community, are asking this question.)