Question

Valgrind detects an invalid read error I don’t know how to fix or to be more precise: I don’t know what the problem is.

Invalid read of size 8
 at 0x443212: std::vector<Tile*, std::allocator<Tile*> >::end() const
 by 0x44296C: Collection<Tile*>::Iterator::operator++()

The Iterator class is very simple (and actually a somewhat bad piece of programming) but sufficient for my needs right now. I think there are three methods you should know to hopefully help find my problem:

Iterator(size_t x, size_t y, const TileCollection& tiles)
        : mTiles(&tiles)
        , mX(mTiles->begin())
        , mY(mTiles->at(x).begin())
{   
       std::advance(mX, x); 
       std::advance(mY, y); 

       bool foundFirst = false;

       while (!foundFirst)
       {
              while (mY != mX->end() && *mY == 0) ++mY;

              if (mY != mX->end()) foundFirst = true;
              else
              {
                     ++mX;

                     if (mX != mTiles->end()) mY = mX->begin();
              }
       }
}

Iterator Iterator::operator++()
{
       bool foundNext = false;

       ++mY;

       while (!foundNext)
       {
              while (mY != mX->end() && *mY == 0) ++mY;

              if (mY != mX->end()) foundNext = true;
              else
              {
                     ++mX;

                     if (mX != mTiles->end()) mY = mX->begin();
              }
       }

       return *this;
}

void TileCollection::add(Tile* tile)
{
       Point2D p(tile->getPosition());

       std::vector<Tile*> tmp(1, (Tile*)0);

       if ((size_t)p.x >= mTiles.size())
              mTiles.resize(p.x + 1, tmp);
       if ((size_t)p.y >= mTiles.at(p.x).size())
              mTiles.at(p.x).resize(p.y + 1, (Tile*)0);

       mTiles.at(p.x).at(p.y) = tile;

       ++mNumTiles;
}

The actual code that is causing the valgrind error is the line:

while (mY != mX->end() && *mY == 0) ++mY;

…of the Iterator::operator++ method.

Answer 1

It looks to me that, at the least, the following line in operator++

if (mX != mTiles->end()) mY = mX->begin();

is lacking a suitable else-clause.

Consider what happens when mX actually reaches mTiles->end(): You will enter a new iteration of the outer while loop; the first line in that loop (the line that causes the Valgrind error) will evaluate mX->end() and thus attempt to dereference mX — but mX is mTiles->end(), and it’s not correct to dereference the end iterator of a collection since it doesn’t actually reference an element of the collection. It looks to me as if this may be the cause of your Valgrind error.

(Note that the constructor contains essentially the same code.)

More generally, I think you need to think about how you handle reaching the end of your two-dimensional array. How does the client of your Iterator check whether it has reached the end of the iteration? How do you expect your operator++ to handle the case when it reaches the end of the two-dimensional array? Should it protect itself against getting called too often?