与 std::minmax_element 一起使用的步长/步长迭代器

我有一个一维浮点数组，它表示 m *n （行和列）浮点值表。我的要求是为每行和每列找到一个最小/最大元素。对于行，我可以通过使用 std::minmax_element 指定 n 个元素的范围来轻松完成此操作。但对于列，我需要使用步幅迭代器，因为放置的元素不是连续的，而是以 n 的步长间隔放置。 boost/STL中有没有标准的迭代器可以使用。另一种选择是编写我自己的版本。 最好的课程是什么？

有两种方法（其中很多）是使用range-v3 https://github.com/ericniebler/range-v3 (or boost::range http://www.boost.org/doc/libs/1_61_0/libs/range/doc/html/index.html) and boost::iterator http://www.boost.org/doc/libs/1_61_0/libs/iterator/doc/index.html.

With range-v3，这是立即的：

#include <iostream>
#include <range/v3/all.hpp>

using namespace ranges;

int main() {
    std::vector<std::size_t> src{1, 2, 3, 4, 5, 6, 7};
    const auto min_max = minmax(src | view::stride(3));
    std::cout << min_max.first << " " << min_max.second << std::endl;
}

In boost::range, use boost::adaptors::strided http://www.boost.org/doc/libs/1_46_1/libs/range/doc/html/range/reference/adaptors/reference/strided.html.

#include <boost/range/adaptor/strided.hpp>
#include <boost/range/algorithm/copy.hpp>
#include <boost/assign.hpp>
#include <boost/range/algorithm.hpp>
#include <algorithm>
#include <iostream>
#include <vector>

int main()
{
    using namespace boost::adaptors;
    using namespace boost::assign;

    std::vector<int> input;
    int arr[] = {1, 2, 3, 4, 5, 6, 7};

    auto str = std::make_pair(&arr[0], &arr[8]) | strided(3);
    std::cout << *boost::range::min_element(str) << " " << *boost::range::max_element(str) << std::endl;
}

请注意以下事项：

1. 范围可以由一对迭代器定义，因此我在这里使用了它，尽管可以使用更简单的形式（它适合堆分配的 C 样式数组的用例）。

2. 不幸的是，这个子库似乎没有min-max（或者至少我找不到它），所以有两个调用，一个用于min，一个用于max。

给定一个随机访问迭代器，构建一个跨步前进并不是很困难boost::iterator_facade http://www.boost.org/doc/libs/1_54_0/libs/iterator/doc/iterator_facade.html:

#include <iostream>
#include <vector>
#include <iterator>
#include <cstddef>
#include <algorithm>
#include <boost/iterator/iterator_facade.hpp>

template<typename It>
class stride_iterator :
    public boost::iterator_facade<
        stride_iterator<It>,
        typename std::iterator_traits<It>::value_type,
        boost::forward_traversal_tag> {
public:
    stride_iterator() = default;
    stride_iterator(It it, It end_it, std::size_t stride) : 
        m_it{it}, m_end_it{end_it}, m_stride{stride} 
    {}

private:
    friend class boost::iterator_core_access;

    void increment() { 
        if(std::distance(m_it, m_end_it) < m_stride) {
            m_it = m_end_it;
            return;
        }
        std::advance(m_it, m_stride);
    }

    bool equal(const stride_iterator<It> &other) const {
        return m_it == other.m_it;
    }

    typename std::iterator_traits<It>::value_type &dereference() const { 
        return *m_it; }

    It m_it, m_end_it;
    std::size_t m_stride;
};

这应该足够了std::minmax_element。 （添加一点逻辑，decrement and advance成员，并更改标签，也会使其成为随机访问迭代器。）

int main() {
    using vec_t = std::vector<int>;
    vec_t v{1, 2, 3, 4, 5, 6, 7};
    stride_iterator<vec_t::iterator> b{std::begin(v), std::end(v), 3}, e{std::end(v), std::end(v), 3};
    auto min_max = std::minmax_element(b, e);
    std::cout << *min_max.first << " " << *min_max.second << std::endl;
}