输入/输出迭代器的不等式运算符的要求

Question

I'm creating a small tile based game. Items in the game store their location in a matrix of buckets. I've implemented this as a class template named Grid which contains a bucket class named Tile .

The Grid is essentially just a wrapper around a std::vector with various accessor methods for converting coords into index keys. It also forwards the vector's iterators so that I can loop over all Tiles in the Grid .

Sometimes though I need to only iterate over a subsection of the Grid . So I've implemented a small class named Section which takes two sets of coords in the constructor to define an AABB. The begin() and end() methods of Section return input/output iterators for looping over all of the tiles inside the AABB.

Its all working but I'm trying to keep the performance of the iterators as close to a nested loop as possible. Basically using a range based for on a Section shouldn't be too much more expensive than:

for (size_t y = 0, end_y = NUM; y < end_y; ++y)
{
    for (size_t x = 0, end_x = NUM; x < end_x; ++x)
    {
        auto& tile = grid[coords_to_key(x, y)];
    }
}

This brings me to the point of the question. I want the inequality operator to be as simple as possible so I've implemented it like so:

bool operator!=(const Section_Iterator& other) const
{
    return m_coords.y < other.m_coords.y;
}

Since the iterator scans each row in the Section sequentially we know that we're 'past the end' when iterator.y >= end.y . This means my inequality operator works for ranged based for loops since under the hood they just check that iterator != end .

The implementation of the operator looks weird though. Like really weird. For example iterator != ++iterator may be true or false. It depends on whether the pre-increment caused the iterator to jump to the next row.

I've been looking at the standard and I think I'm in the clear since they make the distinction between equality and equivalence.

From http://en.cppreference.com/w/cpp/concept/InputIterator

Note, "in the domain of ==" means equality comparison is defined between the two iterator values. For input iterators, equality comparison does not need to be defined for all values, and the set of the values in the domain of == may change over time.

From http://en.cppreference.com/w/cpp/concept/OutputIterator

Equality and inequality may not be defined for output iterators. Even if an operator== is defined, x == y need not imply ++x == ++y.

Honestly though, standardese makes my head spin. Is what I'm doing legal?

Answer 1

After more researching it turns out that what I was doing was not legal according to the standard.

An input iterator must be EqualityComparable . This means that:

• For all values of a, a == a yields true.
• If a == b, then b == a
• If a == b and b == c, then a == c

With my current equality operator a == b does not mean that b == a .

To solve my problem I looked at std::istream_iterator , it is an implementation of an input iterator and naturally anything it does must conform to the standard. The behaviour of its equality operator is described like this:

Checks whether both lhs and rhs are equal. Two stream iterators are equal if both of them are end-of-stream iterators or both of them refer to the same stream

Basically, if both iterators are valid they compare equal. If they are both 'past the end' they compare equal. If one is valid but one is 'past the end' they are not equal.

Applying the same logic to my Section::iterator was easy. The iterator now contains a bool, m_valid . The method begin() always returns an iterator where m_valid == true and the end() method always returns an iterator where m_valid == false .

The iterator's pre-increment operator now tests whether it is past the end and sets the bool accordingly.

Section_Iterator& operator++()
{
    ++m_coords.x;
    if (m_coords.x >= m_section.m_max.x)
    {
        m_coords.x = m_section.m_min.x;
        ++m_coords.y;
        m_valid = (m_coords.y < m_section.m_max.y);
    }

    return *this;
}

The equality operators are now very simple to understand and have consistent behaviour. Any iterator that points to a Tile in the Section is valid and compares equal to any other valid iterator.

bool operator==(const Section_Iterator& other) const
{
    return m_valid == other.m_valid;
}

bool operator!=(const Section_Iterator& other) const
{
    return m_valid != other.m_valid;
}

Answer 2

Honestly I don't know whether what you have done in the above is legal. It certainly has strange semantics, though, even if it is legal.

Instead, I would consider something like this to solve your problem:

#include <iostream>
#include <vector>

struct Grid
{
    std::vector<int> tiles;
    size_t rows;
    size_t cols;
};

class SectionIterator
{
public:
    SectionIterator(Grid * grid, size_t row, size_t col, size_t endRow) :
            m_row{ row },
            m_col{ col },
            m_startRow{ row },
            m_endRow{ endRow },
            m_grid{ grid }
    {
    }

    SectionIterator & operator++()
    {
        ++m_row;
        if (m_row == m_endRow)
        {
            m_row = m_startRow;
            ++m_col;
        }
        return *this;
    }

    bool operator==(const SectionIterator & other) 
    {
        return (m_grid == other.m_grid) 
                && (m_row == other.m_row)
                && (m_col == other.m_col);
    }

    bool operator!=(const SectionIterator & other) 
    {
        return !(*this == other);
    }

    int & operator*() 
    {
        return m_grid->tiles[m_col * m_grid->rows + m_row];
    }

    int * operator->() 
    {
        return &operator*();
    }
private:
    size_t m_row;
    size_t m_col;
    size_t m_startRow;
    size_t m_endRow;
    Grid * m_grid;

};

struct Section 
{
    SectionIterator m_begin;
    SectionIterator m_end;

    SectionIterator begin() { return m_begin; }
    SectionIterator end() { return m_end; }
};

int main() 
{
    Grid grid{ std::vector<int>{ 1, 2, 3, 4, 5, 6 }, 2, 3 };
    // 1, 3, 5 
    // 2, 4, 6

    // look up start and end row and col
    // end positions are found by looking up row/col of section end and then adding one
    size_t startRow = 0;
    size_t endRow = 2;
    size_t startCol = 1;
    size_t endCol = 3;

    SectionIterator begin = SectionIterator{ &grid, startRow, startCol, endRow };
    // Note that the end iterator actually has startRow as its startRow, not endRow, because operator++ will set the iterator's m_row back to startRow so this will make it equal the end iterator once the iteration is complete
    SectionIterator end = SectionIterator{ &grid, startRow, endCol, endRow };
    for (int v : Section{ begin, end })
    {
        std::cout << v << std::endl;
    }
    return 0;
}

Note that this presupposes that you have some function to translate between your co-ordinates and row/col indexes in the grid. Also, the above iterates in a column-major order, but could easily be changed to iterate in a row-major order.

EDIT

To clarify how the conversion from floating point coords to indexes would work, consider the following.

I assume your tiles are defined such that each tile covers a 1x1 square of floating point coordinates. For example, tile (0, 0) covers the floating point intervals [0.0, 1.0), [0.0, 1.0) and tile (2, 2) covers the intervals [2.0, 3.0), [2.0, 3.0). I believe this is how you have described your current setup.

If you wish to iterate all the tiles within the section from (1.2, 1.2) to (4.2, 4.2), first convert these points to row, col indices via truncation:

(1.2, 1.2) = tile (1, 1) (4.2, 4.2) = tile (4, 4)

This means you want to iterate rows in the closed-closed interval [1, 4] and columns in the closed-closed interval [1, 4]. Since iterators like the one above work with closed-open intervals, you must add 1 to the end indexes, such that the values you pass into the iterator represent the intervals [1, 5) for rows and [1, 5) for columns. Note that these intervals are actually the same as the closed-closed interval forms, but the end values represent "one past the last index you want to dereference".

EDIT #2

You indicated that you actually want to make sure that your section finishes on an open interval in floating point coordinates, so that (1.0, 1.0) to (4.0, 4.0) contains 3 tile rows and 3 tile columns, not 4.

You could do this by comparing the end index to the original value and only adding 1 if it's not an integer, so

float coord = ...;
size_t idx = static_cast<size_t>(coord);
constexpr float tolerance = 1e-6f;
if (std::abs(coord - idx) > tolerance)
{
    // Add 1 to make the range include the last tile
    ++idx;
}