C ++ Polymorphism - 继承类的映射

Question

I have a MovementSystem class which inherits from a System class. Later I will have a number of xxxSystem classes so I will store the instances of xxxSystem (there is only one instance per system) in a map this way:

enum
{
    MOVEMENT_SYSTEM
};

std::map<int,std::unique_ptr<System>> systems;
systems[MOVEMENT_SYSTEM] = std::unique_ptr<System>(new MovementSystem());

m_entityManager.loadSystems(&systems);

The last line is there because I need my class EntityManager to have access to all the systems.

Therefore I have this method:

std::map<int,std::unique_ptr<System>> *m_systems; // this line is in the header

void EntityManager::loadSystems(std::map<int,std::unique_ptr<System>> *systems)
{
    m_systems = systems;
}

And finally in an other method of EntityManager I try to access the systems I have sent to the class this way:

std::unique_ptr<MovementSystem> mvt = (*m_systems)[MOVEMENT_SYSTEM];
mvt->update(dt);

But I get this error:

conversion from 'std::map<int, std::unique_ptr<System> >::mapped_type {aka std::unique_ptr<System>}' to non-scalar type 'std::unique_ptr<MovementSystem>' requested

How can I fix this and get the last line to call the update method from MovementSystem ?

Answer 1

std::unique_ptr<MovementSystem> mvt = *m_systems[MOVEMENT_SYSTEM];

There are two problems with this line. One, operator precedence is such that it will get interpreted as this:

*(m_systems[MOVEMENT_SYSTEM])

This means it will apply pointer arithmetic to the pointer m_systems (accessing the MOVEMENT-SYSTEM th element in an "array" pointed to by m_systems ) and then apply * to that map, which is nonsense. What you wanted was this:

(*m_systems)[MOVEMENT_SYSTEM]

The second problem is that you're trying to copy a unique pointer. Which is precisely what unique pointers are designed to prevent.

What you probably want is simply get the pointer, and cast it accordingly:

MovementSystem *mvt = static_cast<MovementSystem*>((*m_systems)[MOVEMENT_SYSTEM].get());

Or, even better because it gets rid of unnecessary pointers:

auto &systems = *m_systems;
auto &mvt = static_cast<MovementSystem&>(*systems[MOVEMENT_SYSTEM]);
mvt.update(dt);