如何正确使用指针向量？

Question

I am making small simulation app, with base class named Entity and children classes named Herbivore and Carnivore. And since I am using SFML, I need to update them, deal with interactions etc, etc. My first idea was to store them in two different vectors, but that's not the most efficient solution, I guess.

Then I've tried using a little bit of polymorphism, but here is where I've utterly failed. I have one vector of pointers to the Entity objects. Here is its declaration:

std::vector<Entity*> entityVector;

While creating new objects, I call function from different class:

void ObjectFactory::createHerbivore(Sprite sprite, Vector2f position, 
std::vector<Entity*> *vector)
{
     Herbivore herbivore(sprite, position, m_GameResolution);
     Entity* p_herbivore = &herbivore;
     vector->push_back(p_herbivore);
}

Here is how I call that function in main Game class:

        //Creating new herbivore objects
        if (inputEvent.key.code == Keyboard::H)
        {
            srand((int)time(0) * dt.asMilliseconds() + 1 * 800 * entityVector.size() + 5);
            herbivorePosition.x = rand() % (int)videoResolution.x;
            herbivorePosition.y = rand() % (int)videoResolution.y;
            factory.createHerbivore(herbivoreSprite, herbivorePosition, &entityVector);
            (entityVector.back())->setDangerSprite(dangerSprite);
        }

And then I proceed to work on that vector, or at least try to, but it crashes by the first try to read data saved under that pointer. Of course, through the painful and long process of debugging I've realised, that I create a new object here, pass its address and then destroy it by leaving this function. So my question is: how to deal with it, so I can keep all of this sweet polymorphism?

Answer 1

” I've realised, that I create a new object here, pass its address and then destroy it by leaving this function. So my question is: how to deal with it, so I can keep all of this sweet polymorphism?

You can have a vector of shared_ptr<Entity> and you can create a new dynamically allocated object with code like make_shared<Herbivore>(sprite, position, m_GameResolution) .

The shared_ptr instead of a raw pointer like Entity* essentially takes care of cleanup. When there are no more shared_ptr s referring to that object, it's automatically destroyed and the memory deallocated. We say that it's owned by the collection of shared_ptr s referring to it.

The make_shared<Herbivore> instead of eg shared_ptr<Entity>{ new Herbivore{ sprite, position, m_GameResolution } } avoids some inefficiency (an extra dynamic allocation) of the latter, and can also help to avoid Undefined Behavior where you create two or more such objects as actual arguments in a function call.

---

Example:

#include <iostream>
#include <typeinfo>     // for typeid
#include <memory>
#include <vector>
using namespace std;

struct Entity { virtual ~Entity(){} };
struct Herbivore: Entity {};
struct Carnivore: Entity {};

auto main() -> int
{
    vector<shared_ptr<Entity>> entities;
    entities.push_back( make_shared<Herbivore>() );
    entities.push_back( make_shared<Herbivore>() );
    entities.push_back( make_shared<Carnivore>() );
    entities.push_back( make_shared<Herbivore>() );

    for( auto p: entities )
    {
        cout << typeid( *p ).name() << endl;
    }
}