Требования оператора неравенства итератора ввода / вывода

Честно говоря, я не знаю, законно ли то, что вы сделали в вышеизложенном. У этого, конечно, есть странная семантика, хотя, даже если это законно.

Вместо этого я хотел бы рассмотреть что-то вроде этого, чтобы решить вашу проблему:

#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;
}

Обратите внимание, что это предполагает, что у вас есть некоторая функция для перевода между вашими координатами и индексами строк / столбцов в сетке. Кроме того, вышеприведенные итерации выполняются в порядке основных столбцов, но их можно легко изменить на итерацию в порядке основных строк.

РЕДАКТИРОВАТЬ

Чтобы уточнить, как будет работать преобразование координат с плавающей запятой в индексы, рассмотрим следующее.

Я предполагаю, что ваши плитки определены так, что каждая плитка покрывает квадрат 1×1 координат с плавающей точкой. Например, плитка (0, 0) покрывает интервалы с плавающей запятой [0.0, 1.0), [0.0, 1.0), а плитка (2, 2) покрывает интервалы [2.0, 3.0), [2.0, 3.0). Я полагаю, что именно так вы описали свои текущие настройки.

Если вы хотите перебрать все плитки в разделе от (1.2, 1.2) до (4.2, 4.2), сначала преобразуйте эти точки в индексы строк, столбцов через усечение:

(1.2, 1.2) = плитка (1, 1)
(4.2, 4.2) = плитка (4, 4)

Это означает, что вы хотите перебирать строки в замкнутом интервале [1, 4] и столбцы в замкнутом интервале [1, 4]. Поскольку итераторы, подобные приведенному выше, работают с закрытыми-открытыми интервалами, необходимо добавить 1 к конечным индексам, чтобы значения, передаваемые в итератор, представляли интервалы [1, 5) для строк и [1, 5) для столбцов. Обратите внимание, что эти интервалы фактически совпадают с формами закрытых и закрытых интервалов, но конечные значения представляют собой «один после последнего индекса, который вы хотите разыменовать».

РЕДАКТИРОВАТЬ № 2

Вы указали, что действительно хотите убедиться, что ваш раздел заканчивается на открытом интервале в координатах с плавающей запятой, так что (1.0, 1.0) — (4.0, 4.0) содержит 3 строки листов и 3 столбца листов, а не 4.

Вы можете сделать это, сравнивая конечный индекс с исходным значением и добавляя только 1, если это не целое число, поэтому

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;
}