Pointer to a vector doesn't point

Question

I have simplified the code as much as possible. So I have two class:

class EntityManager
{
    public:
        std::shared_ptr<std::vector<Entity> > getEntities()
        {
            return std::make_shared<std::vector<Entity> >(m_entities);
        }

    private:
        std::vector<Entity> m_entities{};
};

and

class System
{
    public:
        void loadEntities(std::shared_ptr<std::vector<Entity> > entities)
        {
            m_entities = entities;
        }

    private:
        std::shared_ptr<std::vector<Entity> > m_entities;
};

Now basically I want the m_entities of System to point to the m_entities of EntityManager.

I did this:

system = System();
system.loadEntities(m_entityManager.getEntities());

But then I pushed back an element into the m_entities vector of EntityManager and this element wasn't added in the m_entities vector of System, which means my pointer doesn't point.

Where is my mistake?

Thanks!

Answer 1

Your problem is this line: return std::make_shared<std::vector<Entity> >(m_entities);

What is happening is that the shared_ptr manages a new std::vectory<Entity> container which is initialized as a copy of m_entities. Therefore, modifying the instance in the shared_ptr doesn't modify the data member in the EntityManager class and of course the shared_ptr won't see changes made to EntityManager::m_entities.

Answer 2

std::make_shared doesn't "make this thing shared"; it "makes a thing that will be shared".

So, you can't just make a shared pointer out of nowhere that points to something that already exists.

Your code dynamically allocates a std::vector, copy constructed from m_entities and managed by a std::shared_ptr. It's shorthand for this:

std::vector<Entity>* ptr_to_copy = new std::vector<Entity>(m_entities);
return std::shared_ptr(ptr_to_copy);

It's not clear what you're trying to do, from the code that (by your own admission) does not achieve that goal. But it seems unlikely that std::shared_ptr is appropriate here.

If it is, then make the vector dynamically-allocated and shared from the start; otherwise, just return a reference to the vector as it is.

Answer 3

Hack example of a pointer-free solution.

#include <string>
#include <iostream>
#include <vector>

//Hack-sample Entity class
class Entity
{
    public:
        Entity(const char * name): m_name(name)
        {

        }
        void print() // this is stupid in real life. Prefer a << overload
        {
            std::cout << "Hi! I'm " << m_name << "!\n"; 
        }
    private:
        std::string m_name;
};

class EntityManager
{
    private:
        std::vector<Entity> m_entities;

    public:
        // hide the fact that a vector is being used to store the entities.
        // you can now swap out the vector for most standard containers without
        // changing any code other than the using and the declaration of m_entities
        using iterator = std::vector<Entity>::iterator;

        EntityManager(): m_entities({"bob", "bill"}) 
                         // just pre-loading a few test entities
        {
            // RAII says you should load the entities from their source here
        }
        // get the first entity. 
        iterator begin()
        {
            return m_entities.begin();
        }
        // get the end of the entity list
        iterator end()
        {
            return m_entities.end();
        }

        // adds an entity
        void addEntity(const Entity & entity)
        {
            m_entities.push_back(entity);
        }

        // removes an entity
        iterator removeEntity(iterator rem)
        {
            return m_entities.erase(rem);
        }

};

class System
{
    public:

        // example method to show System working with EntityManager by printing all of the Entities
        void printEntities()
        {
            for (EntityManager::iterator it = m_entityManager.begin();
                 it != m_entityManager.end();
                 ++it)
            {
                it->print();
            }
        }

        // example method to show System working with EntityManager by adding Entities
        void addMoreEntities()
        {
            m_entityManager.addEntity(Entity("Ted \"Theodore\" Logan"));
            m_entityManager.addEntity(Entity("Excellent!!!"));
        }

    private:
        EntityManager m_entityManager ;
};

// sample test
int main()
{
    System test;

    test.printEntities();
    test.addMoreEntities();
    test.printEntities();

}

THIS HAS BEEN A HACK. THIS HAS ONLY BEEN A HACK.

If you want to do EntityManager right, see Writing your own STL Container for hints. If you want all of the bells and whistles, the job is fairly complicated. Depending on how you are using EntityManager and the complexity of the Entity management logic, you may be better off discarding EntityManager and just using the plain, old std::vector.

Addendum: What is meant by Resource Acquisition is Initialization (RAII)?