Dynamic Entity reDefinition : C++

#include <iostream>
#include <map>
#include <functional>

template <class M = std::string, class E = int>
E log(M msg, E error = 0)
{
    std::cout << msg;
    return error;
}

//static int const POSITION = 1;
//static int const VELOCITY = 2;

enum
{
    POSITION = 10,
    VELOCITY
};


struct Component
{
    int _type;
    virtual Component *clone() const = 0;
    virtual ~Component() // Avoid warning when we want to delete Component !
    {

    }
};


template <class DERIVED>
struct ComponentHelper : public Component
{
    virtual Component *clone() const
    {
        return new DERIVED(static_cast<const DERIVED&>(*this));
    }
};


struct Position : public ComponentHelper<Position>
{
    int _x;
    int _y;
    int _z;

    Position(int x = 0, int y = 0, int z = 0)
    {
        _type = POSITION;
        _x = x;
        _y = y;
        _z = z;
    }
};

struct Velocity : public ComponentHelper<Velocity>
{
    int _x;
    int _y;
    int _z;

    Velocity(int x = 0, int y = 0, int z = 0)
    {
        _type = VELOCITY;
        _x = x;
        _y = y;
        _z = z;
    }
};

struct Entity
{
    std::string _name="";

    Entity *_parent = nullptr;

    std::map<int, Component*> _mapMember;

    std::function<void(Entity*)> _update = nullptr;
    std::function<void(Entity*)> _render = nullptr;

    void setUpdate(std::function<void(Entity*)> update)
    {
        _update = update;
    }

    void setRender(std::function<void(Entity*)> render)
    {
        _render = render;
    }


    static Entity *cloneOf(Entity *original, std::string name = "")
    {


        Entity *clone = new Entity(*original);

        if (name == "")
            clone->_name = original->_name;
        else
            clone->_name = name;


        //clone = original;
        log ("--- Begin deep copy ---\n");
        std::map<int,Component*>::const_iterator it = original->_mapMember.begin();

        while (it != original->_mapMember.end())
        {
            //clone->_mapMember[it->first] = new Component(*(it->second));
            clone->_mapMember[it->first] = (*(it->second)).clone();
            it++;
        }
        return clone;
    }

    Entity(Entity *parent = nullptr, std::string name="")
    {
        _name = name;
        _parent = parent;

        log("- Entity created !\n");
    }
    virtual ~Entity()
    {
        std::map<int,Component*>::iterator it = _mapMember.begin();

        while (it != _mapMember.end())
        {
            if (it->second != nullptr)
            {
                log ("- Delete Component:"+ std::to_string(it->second->_type) + " of Entity: " + _name + "\n");
                delete it->second;
                it->second = nullptr;
            }

            it++;
        }
        _mapMember.clear();

        log("- Delete Entity: " + _name + "\n");
    }

    void add(Component* component)
    {
        _mapMember[component->_type] = component;
    }

    void del(int type)
    {
        delete _mapMember[type];
        _mapMember.erase(type);
    }


    template <class COMPONENT>
    COMPONENT *get()
    {
        COMPONENT component;
        return static_cast<COMPONENT*>(_mapMember[component._type]);
    }

    void update()
    {
        if (_update != nullptr)
            _update(this);
        else
            log("- Entity update() not defined !\n");
    }

    void render()
    {


        if (_render != nullptr)
            _render(this);
        else
            log("- Entity render() not defined !\n");

    }
};

Entity * createPlayer(Entity *parent, std::string name)
{
    Entity *entity = new Entity(parent, name);

    entity->add(new Position());
    entity->add(new Velocity());

    return entity;
}

void showMe(Entity * entity)
{
    log("****************\n");
    log("* Name = ");log(entity->_name);log("\n");
    log("****************\n");

    std::map<int,Component*>::iterator it = entity->_mapMember.begin();

    while (it != entity->_mapMember.end())
    {
        if (it->second != nullptr)
        {

            if (it->second->_type == POSITION)
            {
                log("--- Position ---\n");
                log("- x = ");log(entity->get<Position>()->_x);log("\n");
                log("- y = ");log(entity->get<Position>()->_y);log("\n");
                log("- z = ");log(entity->get<Position>()->_z);log("\n");
            }

            if (it->second->_type == VELOCITY)
            {
                log("--- Velocity ---\n");
                log("- x = ");log(entity->get<Velocity>()->_x);log("\n");
                log("- y = ");log(entity->get<Velocity>()->_y);log("\n");
                log("- z = ");log(entity->get<Velocity>()->_z);log("\n");
            }
        }
        it++;
    }
}

int main()
{

// Init

    //Entity *player = new Entity(nullptr, "Mugen");

    Entity *player = createPlayer(nullptr, "Mugen");

    player->setRender([&](Entity *entity)
    {
        log("---------------------\n");
        log("||- I am a PLAYER -||\n");
        log("---------------------\n");
    });

    player->add(new Position(10,20,30));
    player->add(new Velocity(1,2,3));

    player->get<Position>()->_x = 99;
    player->get<Position>()->_y = 88;

    player->get<Velocity>()->_z = 888888;


    Entity *monster0 = new Entity(nullptr, "Monster");

    monster0->setRender(showMe);

    monster0->add(new Position());
    monster0->add(new Velocity(77,55,33));

    monster0->get<Velocity>()->_x = -666;
    monster0->get<Velocity>()->_y = -666;
    monster0->get<Position>()->_z = 454545;

    //Entity *copyPlayer = new Entity(nullptr, "MugenCopy");
    Entity *copyPlayer = Entity::cloneOf(player);

    Entity *monster1 = Entity::cloneOf(monster0, "Monster1");
    Entity *monster2 = Entity::cloneOf(monster0);

    monster1->get<Position>()->_z = 11111111;
    monster1->get<Velocity>()->_z = 11111111;

    monster2->get<Position>()->_x = 22222222;
    monster2->get<Position>()->_y = 22222222;
    monster2->get<Position>()->_z = 22222222;

    Entity *monster3 = Entity::cloneOf(monster1,"Monster3 : Clone of Monster1");


    player->setRender(showMe);

    player->del(POSITION);

    monster2->del(POSITION);
    monster2->del(VELOCITY);


// Render

    player->render();
    copyPlayer->render();

    monster0->render();
    monster1->render();
    monster2->render();

    monster3->render();


// done

    delete player;
    delete copyPlayer;

    delete monster0;
    delete monster1;
    delete monster2;

    delete monster3;

    return log("--- --- End of main OK --- ---\n");
}