Hello there.

I want to make a list of entities that are gonna be updated every tick. So, I created a class named Entity, and gave it a couple of functions:

class Entity{
    public:
        int uniqueID;

        Vec3f loc;
        Vec2f res;
        Vec2f vel;
        float rot;

        virtual void onUpdate();
        virtual void onSpawned();
        virtual string getNameID();
        vector<GameData> gameData;
};

Then, I created a vector of these entities:

vector<Entity> entities;

After that, I wanted an arrow entity, so I created a new class EntityArrow that is an extension of Entity:

class EntityArrow : public Entity{
    public:
        EntityArrow();
        EntityArrow(Vec3f argLoc,Vec2f argRes);
        string getNameID();
        void onUpdate();
        void onSpawned();
};

And now comes the problem, when I try to add a new EnttiyArrow to the entities list: entities.push_back(EntityArrow()); it is still treated as an Entity. For instance, if I overrided the onUpdate() function in EntityArrow to print out something in the console, it would do something that is in the Entity's onUpdate() , and not the EntityArrow's. I have already tried to make a vector out of references to Entity class : vector<Entity*> entities , but I still have a lot of problems with it.

Is there a better way to do it? Thanks in advance :).

Look up slicing; your vector stores Entity objects by value, so only the Entity part of your EntityArrow ends up in the vector. Your vectors has to store pointers and you need to allocate your Entity objects dynamically instead.

So I should use this method right? vector<Entity*> entities

Well, if yes, than I still have problems with it. Sure, it works for the aspect of overriding the functions properly, but sometimes when I try to render it or just add another entity, it doesn't show up, or just doesn't add to the vector.

Is this method of adding the Entity into the vector correct?

EntityArrow arrow = EntityArrow();
entities.push_back(&arrow);

That's not correct. When Brother Bob said you have to allocate the entity objects dynamically he meant that you need to allocate them with the new operator. This means you have to delete them when you remove them too.

EntityArrow *arrow = new EntityArrow();
entities.push_back(arrow);

To avoid the need for manual deletion you can use smart pointers:

// Requires C++11 compiler

std::vector<std::unique_ptr<Entity>> entities;

entities.push_back(std::unique_ptr<Entity>(new EntityArrow()));

Edit: Apologies for the similar post. The previous one wasn't there when I started writing it. It's not quite a duplicate though - the choice of smart pointer is different.

// removing entities
entities.erase(it);
delete *it; // make sure to delete the entity being removed from the list

Thanks for everything guys :)

Contrary to what the other people said, the simplest solution is to not throw all entities into one vector only to later having to check their type through virtual calls.

The point of templates is that they know the exact type:

vector<EntityArrow> arrows;

Btw., if you create a large hierarchy of classes derived from Entity you'll probably discover later that it leads to problems. You'll be tempted to duplicate some aspects or move unrelated things up in the hierarchy where they not belong, because not all objects can be categorized into a regular tree. Better to avoid that from beginning and use composition instead of inheritance.

That the type of vector<Entity*> is well known is true, but irrelevant and I did not write that it was not.

What I tried to hint at was that the problem stems from using vector<Entity> and filling it with objects that are only derived from Entity. Then I gave the example of fixing it by using vector<EntityArrow>, which is a different and possibly better/easier solution than switching to a pointer type.

Btw., he explicitly asked if there was a better way to do it, therefore its not wrong to tell him there are other solutions than going the way of polymorphism. I could have elaborated it more, but I first wanted to see how much he would be interested in that.