How do I avoid having to forward declare (and thus violating the DRY principle) given the following:

World.h

#include "Entity.h"

class Entity;
typedef std::shared_ptr<Entity> Entity_ptr;
typedef unsigned int entity_id;

class World
{
public:
	void add_entity(Entity_ptr entity);
	void remove_entity(entity_id entityId);
};

typedef std::shared_ptr<World> World_ptr;

Entity.h

#include "World.h"

typedef unsigned int entity_id;

class World;
typedef std::shared_ptr<World> World_ptr;

class Entity
{
public:
	World_ptr world() const { return world_; }
	void set_world(World_ptr world) { world_ = world; }
};

typedef std::shared_ptr<Entity> Entity_ptr;

Because each file depends on the other, neither can compile unless I forward declare the class and the typedef for the shared_ptr.

I've not coded with C++ in, oh, about eight years. So I'm a little rusty.

Thanks!

Worlds contain Entities. Entitys point to worlds. Entities do not own the world, but the world does own the entities.

World contains a container of entities (shared_ptrs if you like, or unique_ptrs). So World.h #includes Entity.h.

Entity contains a raw pointer to the world. Why? It does not own 'World', so a shared_ptr doesn't fit. Further, the lifetime of World is guaranteed to be longer than Entity, so even weak_ptr is unnecessary. Solution? Entity contains a raw pointer to World (or rather, a reference - since it doesn't change worlds later). So Entity.h forward-declares World.

Problem solved! Really not much of a conundrum, in this case, as ownership is clear.

Entity contains a raw pointer to the world. Why? It does not own 'World', so a shared_ptr doesn't fit.

Thanks for that. I didn't think about ownership in the context of shared_ptr. I just thought it was good practice to always use some sort of "managed" pointer.

Btw, if they've both got shared_ptrs to each other, then you've got a circular loop of reference counting, so they'll never be deleted automatically (making shared_ptr about as good as a raw pointer).

Thanks! I didn't think about circular references. I can see that I'm /really/ going to enjoy this C++ excursion...