Реализация паттерна Entity-Component-System

#include <string>
#include <map>
#include <iostream>
#include <list>
#include <cstdint>
 
class EntityManager;
 
class IEntity
{
    friend class EntityManager;
public:
    virtual void foo() = 0; // public interface
    
    uint64_t id() const
    {
        return m_id;
    }
    std::string name() const
    {
        return m_name;
    }
    
protected:
    explicit IEntity(uint64_t id, std::string const & name)
        : m_id(id), m_name(name)
    { }
    
    virtual ~IEntity() = 0;
    
private:
    uint64_t m_id;
    std::string m_name;
};
 
IEntity::~IEntity() // in cpp
{ }
 
//-----------------------------------------------------------------
 
class EntityManager
{
public:
    ~EntityManager();
    
    template <typename Registerable>
    void Register(const std::string &name);
    
    IEntity * Create(const std::string &type, const std::string &name);
    
private:
    uint64_t getNextId()
    {
        return m_nextId++;
    }
    
private:
    std::map<std::string, IEntity * (*)(uint64_t, std::string const &)> m_prototypes;
    std::list<IEntity *> m_entities;
    
    uint64_t m_nextId = 0;
};
 
IEntity * EntityManager::Create(const std::string &type, const std::string &name)
{
    auto fit = m_prototypes.find(type);
    if(fit != m_prototypes.end())
    {
        auto ient = fit->second(getNextId(), name);
        m_entities.push_back(ient);
        return ient;
    }
    return nullptr;
}
 
template <typename Registerable>
void EntityManager::Register(std::string const & name)
{
    m_prototypes.insert({ name, &Registerable::Create });
    // additional checks
}
 
EntityManager::~EntityManager()
{
    for(auto & entity : m_entities)
    {
        delete entity;
    }
}
//-------------------------------------------------------------------------
 
// Mix-in Registerable allows to register types to Сreate
template <typename D>
class Registerable
{
    friend class EntityManager;
private:
    static IEntity * Create(uint64_t id, std::string const & name)
    {
        return new D(id, name);
    }
};
 
class Hero 
    : public IEntity
    , public Registerable<Hero> // Hero is Registerable type
{
    friend class Registerable<Hero>; // Ability to call private constructors from Registerable 
public:
    void foo() override
    {
        std::cout << "This is " << name() << std::endl;
    }
    
private:
    Hero(uint64_t id, std::string const & name)
        : IEntity(id, name)
    { }
 
    ~Hero() = default;
};
 
int main()
{
    EntityManager enManager;
 
    enManager.Register<Hero>("Hero");
 
    IEntity * ihero = enManager.Create("Hero", "Vasya"); // Creating Hero named Vasya
    if(ihero)
    {
        ihero->foo();
        
        Hero * hero = static_cast<Hero *>(ihero); 
        
        // do something with hero
        
        (void)hero;
    }
}