Универсальные многомерные итераторы С++

В моем текущем проекте я имею дело с многомерной структурой данных. Основной файл хранится последовательно (т.е. Один огромный массив, вектор векторов нет). Алгоритмы, использующие эти структуры данных, должны знать размер отдельных измерений.

Мне интересно, был ли определен многомерный класс итератора где-то в общем виде и если есть какие-либо стандарты или предпочтительные способы решения этой проблемы.

В настоящий момент я просто использую линейный итератор с некоторыми дополнительными методами, которые возвращают размер каждого измерения и количество измерений в первой части. Причина, по которой мне это не нравится, заключается в том, что я не могу использовать std:: distance разумным способом (например, только возвращает расстояние всей структуры, но не для каждого измерения отдельно).

По большей части я получаю доступ к структуре данных линейным образом (первое измерение начинается до конца → следующее измерение +... и т.д.), но было бы полезно знать, когда одно измерение "заканчивается". Я не знаю, как это сделать с помощью оператора *(), оператора +() и оператора ==() в таком подходе.

Подход вектора векторов неблагоприятен, потому что я не хочу разделить файл. Также алгоритмы должны работать на структуре с различной размерностью и поэтому трудно обобщить (или, может быть, есть способ?).

У Boost multi_array есть те же проблемы (несколько "уровней" итераторов).

Надеюсь, это не слишком расплывчато или абстрактно. Любой намек в правильном направлении был бы оценен.

Я снова искал решение и пересматривал boost:: multi_array. Как оказалось, можно генерировать подвыборы для данных с ними, но в то же время также взять прямой итератор на верхнем уровне и неявно "сгладить" структуру данных. Однако реализованные версии multi_array не соответствуют моим потребностям, поэтому я, вероятно, сам реализую один (который обрабатывает кеширование файлов в фоновом режиме), который совместим с другими multi_arrays.

Я обновлю его снова после выполнения.

ОТВЕТЫ

Ответ 1

Я только что решил открыть публичный репозиторий в Github: MultiDim Grid, который может помочь вам в ваших потребностях. Это постоянный проект, поэтому Я был бы рад, если вы сможете попробовать и рассказать мне, что вам не хватает/нужно.

Я начал работать над этим с помощью темы в кодере.

Проще говоря:

MultiDim Grid предлагает плоский одномерный массив, который предлагает общий быстрый доступ между многомерными координатами и сглаживание индекс.

Вы получаете поведение контейнера, поэтому у вас есть доступ к итераторам.

Ответ 2

Это не так сложно реализовать. Просто укажите, какую функциональность требуется вашему проекту. Здесь немой образец.

#include <iostream>
#include <array>
#include <vector>
#include <cassert>

template<typename T, int dim>
class DimVector : public std::vector<T> {
public:
    DimVector() {
        clear();
    }

    void clear() {
        for (auto& i : _sizes)
            i = 0;
        std::vector<T>::clear();
    }

    template<class ... Types>
    void resize(Types ... args) {
        std::array<int, dim> new_sizes = { args ... };
        resize(new_sizes);
    }

    void resize(std::array<int, dim> new_sizes) {
        clear();
        for (int i = 0; i < dim; ++i)
            if (new_sizes[i] == 0)
                return;
        _sizes = new_sizes;
        int realsize = _sizes[0];
        for (int i = 1; i < dim; ++i)
            realsize *= _sizes[i];
        std::vector<T>::resize(static_cast<size_t>(realsize));
    }

    decltype(auto) operator()(std::array<int, dim> pos) {
        // check indexes and compute original index
        size_t index;
        for (int i = 0; i < dim; ++i) {
            assert(0 <= pos[i] && pos[i] < _sizes[i]);
            index = (i == 0) ? pos[i] : (index * _sizes[i] + pos[i]);
        }
        return std::vector<T>::at(index);
    }

    template<class ... Types>
    decltype(auto) at(Types ... args) {
        std::array<int, dim> pos = { args ... };
        return (*this)(pos);
    }

    int size(int d) const {
        return _sizes[d];
    }


    class Iterator {
    public:
        T& operator*() const;
        T* operator->() const;
        bool operator!=(const Iterator& other) const {
            if (&_vec != &other._vec)
                return true;
            for (int i = 0; i < dim; ++i)
                if (_pos[i] != other._pos[i])
                    return true;
            return false;
        }
        int get_dim(int d) const {
            assert(0 <= d && d < dim);
            return _pos[d];
        }
        void add_dim(int d, int value = 1) {
            assert(0 <= d && d < dim);
            _pos[d] += value;
            assert(0 <= _pos[i] && _pos[i] < _vec._sizes[i]);
        }
    private:
        DimVector &_vec;
        std::array<int, dim> _pos;
        Iterator(DimVector& vec, std::array<int, dim> pos) : _vec(vec), _pos(pos) { }
    };

    Iterator getIterator(int pos[dim]) {
        return Iterator(*this, pos);
    }

private:
    std::array<int, dim> _sizes;
};

template<typename T, int dim>
inline T& DimVector<T, dim>::Iterator::operator*() const {
    return _vec(_pos);
}

template<typename T, int dim>
inline T* DimVector<T, dim>::Iterator::operator->() const {
    return &_vec(_pos);
}

using namespace std;

int main() {

    DimVector<int, 4> v;
    v.resize(1, 2, 3, 4);
    v.at(0, 0, 0, 1) = 1;
    v.at(0, 1, 0, 0) = 1;

    for (int w = 0; w < v.size(0); ++w) {
        for (int z = 0; z < v.size(1); ++z) {
            for (int y = 0; y < v.size(2); ++y) {
                for (int x = 0; x < v.size(3); ++x) {
                    cout << v.at(w, z, y, x) << ' ';
                }
                cout << endl;
            }
            cout << "----------------------------------" << endl;
        }
        cout << "==================================" << endl;
    }
    return 0;
}

Список TODO:

  • optimize: используйте T const&, если возможно
  • оптимизировать итератор: предварительно скомпилировать realindex, а затем просто изменить это realindex
  • реализовать const accessors
  • реализовать ConstIterator
  • реализовать operator>> и operator<< для сериализации DimVector в/из файла