Entity management design & smart pointers
The fact that AddEntity leaves behind a unique_ptr to a possibly destroyed entity bothers me (right now, moving your entity does not "destroy" it, but you might add destructible components later). In my opinion, AddEntity should not take its argument by pointer but by reference:

void EntityManager::AddEntity(const Entity&amp; entity) {
    mEntities.push_back(entity);
}


You can provide an overload for rvalue-references to move entities that are meant to disappear anyway though:

void EntityManager::AddEntity(Entity&amp;&amp; entity) {
    mEntities.push_back(std::move(entity));
}


You probably didn't care because in your use case, you passed temporary variables that are destroyed right after having been created. But what you might actually want to do is to create the entities directly in the vector insteas of creating them, then adding them to the vector. Therefore, what you really need is an emplace_back function:

template&lt;typename... Args&gt;
void EntityManager::EmplaceEntity(Args&amp;&amp;... args) {
    mEntities.emplace_back(std::forward&lt;Args&gt;(args)...);
}


With such a function, you can init your world like this:

void World::Init() {
    // Add some initial entities
    for( int i=0 ; i &lt; 200; i++ ) {
        mEntityManager.EmplaceEntity(*this);
    }
}




EDIT: Answering your comment. If Entity is an abstract class and you only add instances of derived classes, then I think that push_back still works fine since polymorphism will be achieved via reference semantics. On the other hand, EmplaceEntity could take another argument if you want to emplace instances of classes derived from Entity:

template&lt;typename Derived, typename... Args&gt;
void EntityManager::EmplaceEntity(Args&amp;&amp;... args) {
    std::unique_ptr&lt;Entity&gt; ptr( new Derived{std::forward&lt;Args&gt;(args)...} );
    mEntities.push_back(std::move(ptr));
}


I did not test the code above, but theorically it should. That allows you to create instances of classes derived from Entity directly without having to bother with the pointers. Here is how you could use it:

mEntityManager.EmplaceEntity&lt;BlueEntity&gt;(*this);


Anyway, whenever possible, try to use reference smantics and to hide pointer semantics inside the classes so that the users of the classes don't have to bother with the pointers.