Question

I have a list of pointers to a base abstract class (Entity)

std::list<Entity*> m_entities;

I have created a typedef for iterating through this class

typedef std::list<Entity*>::const_iterator entityIter;

I then try and iterate through each pointer in the list

for (entityIter i = m_entities.begin(); i != m_entities.end(); ++i)
{
    const Entity &e = *i;    // ERROR
    e.DoStuff();
}

I get the following error when attempting to reference each pointer

IntelliSense: no suitable constructor exists to convert from “Entity *const” to “Entity”

What have I done incorrectly?

EDIT:

I have tried to use std::shared_ptr

std::list<std::shared_ptr<Entity>> m_entities;

I can’t add to the list this way though

Entity::Entity(Game *game) 
    : m_game(game)                  
{
    m_game->g_idGenerator->generateNewID();

    m_game->m_entities.push_back(this);      // ERROR
}

Using the following

m_game->m_entities.push_back(std::shared_ptr<Entity>(this));

gives me this error

error C2664: ‘void std::list<_Ty>::push_back(_Ty &&)’ : cannot convert parameter 1 from >’Entity’ to ‘std::tr1::shared_ptr<_Ty> &&’

EDIT 2:

Current code summary

for (entityIter i = m_entities.begin(); i != m_entities.end(); ++i)
{
    // *i dereferences the iterator and returns an Entity*
    // **i would additionally deference the pointer
    // Adding 'const' infront of Entity means that I can't alter the Entity
    Entity &e = **i;

    e.draw(dt);   // Causes access violation error with standard pointers
}   

Have tried converting to std:shared_ptr to see if it would avoid the error triggered by the code above.

However, I am now having trouble adding the Entity to the list of std::shared_ptr

    m_game->m_entities.push_back(std::shared_ptr<Entity>(this));

So in summary I have the access violation error with a standard pointer and I can’t add to the list with a shared_ptr.

Populating the list is done via the constructor of the base Entity class

Entity::Entity(Game *game) 
    : m_game(game)                  
{
    m_game->g_idGenerator->generateNewID();

            // shared_ptr version
    m_game->m_entities.push_back(std::shared_ptr<Entity>(this));  // ERROR C2664

            // raw pointer version
            //m_game->m_entities.push_back(this);  // ACCESS VIOLATION ERROR when calling methods
}

Answer 1

const Entity &e = *i;

*i dereferences the iterator and returns an Entity*.

**i would additionally deference the pointer.

To avoid keeping the reference around, you can use (*i)->memberFunction(...);

Don’t forget that if you allocated the Entity’s with operator new that you also need to operator delete them.

Here is an example using std::shared_ptr since your code is looking to complex to discuss on a page.

I created a trivial Entity class and used it in std::shared_ptr. I put the same std::shared_ptr<Entity> multiple times purely for demonstration that std::shared_ptr manages this information including copying itself into the list.

#include <memory>
#include <iostream>
#include <string>
#include <list>
using namespace std;

class Entity {
private:
  string name;
public:
  Entity(const std::string& n) :
    name(n)
  { }

  const string& getName() {
    return name;
  }
};

int main(int argc, char** argv) {
  list<shared_ptr<Entity> > l;

  shared_ptr<Entity> sp(new Entity("Repeated!"));

  l.push_back(sp);
  l.push_back(sp);
  l.push_back(shared_ptr<Entity>(new Entity("Foo")));
  l.push_back(sp);
  l.push_back(shared_ptr<Entity>(new Entity("Bar")));
  l.push_back(sp);

  for(list<shared_ptr<Entity> >::const_iterator iter = l.begin();
      iter != l.end(); ++iter)
    {
      cout << ">> " << (*iter)->getName() << endl;
    }
};

Note: There is a difference between you putting the exact same raw pointer into multiple std::shared_ptr objects and copying a std::shared_ptr as push_back does. The latter case is fully managed by std::shared_ptr while the former case has each std::shared_ptr attempting to manage independently.