使用 C++20 在相等的范围内迭代

Question

我想知道 C++20 范围是否有一些很好的方法可以让我遍历排序容器的相等范围（或在一般情况下任何排序范围）。

我有这个有效的“手动”解决方案，但从某种意义上说，它并不是真正可组合的（我没有得到一些等距视图的视图，我只是提供了要调用的函数）。

#include <vector>
#include <ranges>
#include <iostream>
#include <fmt/ranges.h>


template<typename Cont, typename Fn>
void for_each_equal_range(const Cont& cont, Fn fn){
    auto current_begin = cont.begin();
    while(true){
        if (current_begin==cont.end()){
            return;
        }
        auto [eq_begin, eq_end] = std::equal_range(current_begin, cont.end(),   *current_begin);
        fn(eq_begin, eq_end);
        current_begin = eq_end;
    }
}

int main() {
    std::vector vals {1,2,2,3,3,3,47};
    for_each_equal_range(vals, [](const auto b, const auto e){
        std::cout << "size: " << std::distance(b,e) << std::endl;
        std::ranges::subrange elems(b, e);
        std::cout << fmt::format("{}",elems) << std::endl;
    });
}

我希望我有这样的东西：

vals | equal_range_split | std::ranges::for_each(...);

万一有一些混淆wrt范围在这里意味着什么：

• 相等范围是很好的旧 STL equal_range 含义
• 范围是 C++20 范围库。

我也知道 C++20 有std::ranges::equal_range算法，但它似乎对我的用例没有帮助。

Answer 1

不完全是你要找的，但如果你有一个协程生成generator模板，比如

using namespace std::ranges;

template<typename Range, typename Compare = std::less>
generator<subrange<iterator_t<Range>>> equal_ranges(Range&& range, Compare compare = {}) {
    for (auto current_begin = cont.begin(); current_begin != cont.end();) {
        auto [eq_begin, eq_end] = std::equal_range(current_begin, cont.end(), *current_begin, compare);
        co_yield { eq_begin, eq_end };
        current_begin = eq_end;
    }
}

template<typename Compare>
struct equal_ranges_holder {
    Compare compare;
};

template<typename Compare = std::less>
equal_ranges_holder<Compare> equal_ranges(Compare compare = {}) { return { compare }; } 

template<typename Range, typename Compare>
auto operator|(Range&& range, equal_ranges_holder<Compare> holder) {
    return equal_ranges(range, holder.compare);
}

或者，使单次通过equal_range_view相当简单。

using namespace std::ranges;

template<borrowed_range Range, std::strict_weak_order Compare = std::less>
class equal_range_view : public view_interface<equal_range_view> {
    using base_iterator = iterator_t<Range>;
    using base_sentinel = sentinel_t<Range>;

    Range range;
    Compare compare;
public:
    class sentinel {};

    class iterator {
        base_iterator base;
        base_sentinel end;
        Compare compare;
    public:
        using value_type = subrange<base_iterator>;
        using reference = value_type;
        using pointer = value_type *;
        using difference_type = std::ptrdiff_t;
        using iterator_category = std::input_iterator_tag;
    
        equal_range_iterator(base_iterator base, base_sentinel end, Compare compare) : base(base), end(end), compare(compare) {}

        reference operator*() {
            auto [first, last] = std::equal_range(base, end, compare);
            return { first, last };
        }
    
        iterator& operator++() {
            auto [_, last] = std::equal_range(base, end, compare);
            base = last;
            return *this;
        }

        bool operator==(sentinel) const {
            return base == end;
        }
        bool operator!=(sentinel) const {
            return base != end;
        }
    }; 

    explicit equal_range_view(Range range, Compare compare = {}) : range(range), compare(compare) {}

    iterator begin() { return { range.begin(), range.end(), compare }; }
    sentinel end() { return {}; }
};

Answer 2

在 C++20 中，管道运算符还没有为std::ranges::equal_range和std::ranges::for_each 。 实现上述代码的简单技术如下：

  for (int global = *vals.begin() - 1 ; 
           auto val : vals | std::ranges::views::filter([&](auto value){return value != global ;}))
    {
        std::ranges::for_each(std::ranges::equal_range(vals, val), [](auto& x){ std::cout << x << std::endl; });
        global = val;
    }