如何使用标准库迭代相等的值？

Question

假设我有一个东西的向量：

std::vector<Foo> v;

此向量已排序，因此相等的元素彼此相邻。

获取表示具有相等元素的范围的所有迭代器对的最佳方法是什么（使用标准库）？

while (v-is-not-processed) {
    iterator b = <begin-of-next-range-of-equal-elements>;
    iterator e = <end-of-next-range-of-equal-elements>;

    for (iterator i=b; i!=e; ++i) {
        // Do something with i
    }
}

我想知道如何在上面的代码中获取b 和e 的值。

例如，如果v 包含这些数字：

 index 0 1 2 3 4 5 6 7 8 9
 value 2 2 2 4 6 6 7 7 7 8

然后我想让b 和e 指向循环中的元素：

 iteration  b  e
 1st        0  3
 2nd        3  4
 3rd        4  6
 4th        6  9
 5th        9 10

有没有一种优雅的方法可以用标准库解决这个问题？

Answer 1

这基本上是 Range v3 的 group_by: group_by(v, std::equal_to{})。它在 C++17 标准库中不存在，但我们可以编写自己的粗略等价物：

template <typename FwdIter, typename BinaryPred, typename ForEach>
void for_each_equal_range(FwdIter first, FwdIter last, BinaryPred is_equal, ForEach f) {
    while (first != last) {
        auto next_unequal = std::find_if_not(std::next(first), last,
            [&] (auto const& element) { return is_equal(*first, element); });

        f(first, next_unequal);
        first = next_unequal;
    }
}

用法：

for_each_equal_range(v.begin(), v.end(), std::equal_to{}, [&] (auto first, auto last) {
    for (; first != last; ++first) {
        // Do something with each element.
    }
});

Answer 2

您可以使用std::upper_bound 将迭代器获取到“下一个”值。由于std::upper_bound 将迭代器返回到大于所提供值的第一个元素，如果您提供当前元素的值，它将为您提供一个超过当前值末尾的迭代器。这会给你一个像

这样的循环

iterator it = v.begin();
while (it != v.end()) {
    iterator b = it;
    iterator e = std::upper_bound(it, v.end(), *it);

    for (iterator i=b; i!=e; ++i) {
        // do something with i
    }
    it = e; // need this so the loop starts on the next value
}

Answer 3

您正在寻找std::equal_range。

返回一个范围，其中包含与 范围[第一，最后）。

类似下面的东西应该可以工作。

auto it = v.begin();
while (it != v.end())
{
    auto [b, e] = std::equal_range(it, v.end(), *it);
    for (; b != e; ++b) { /* do something in the range[b, e) */ }
    it = e;             // need for the beginning of next std::equal_range
}

---

^{备注：尽管这将是一种直观的方法，std::equal_range 获得了它的 first 和 second 迭代器（即b 和 e) 在 std::lower_bound 和 std::upper_bound 的帮助下，这使得这个 approche slightly inefficient。因为，对于 OP 的情况，first 迭代器可以很容易地访问，只需要为 second 迭代器调用 std::upper_bound（如 @NathanOliver 所示的答案）。}

Answer 4

如果您的相等值范围很短，那么std::adjacent_find 会很好用：

for (auto it = v.begin(); it != v.end();) {
    auto next = std::adjacent_find(it, v.end(), std::not_equal_to<Foo>());
    for(; it != next; ++it) {

    }
}

如果您愿意，也可以用 lambda 替换 std::not_equal_to。

Answer 5

但是即使我们不使用 e 来表示任何东西，这个公式也很方便，而且更难出错。另一种方法（检查值的变化）更繁琐（因为我们需要特别处理最后一个范围[...]）

取决于你如何理解'特别处理最后一个范围'：

auto begin = v.begin();
// we might need some initialization for whatever on *begin...
for(Iterator i = begin + 1; ; ++i)
{
    if(i == v.end() || *i != *begin)
    {
        // handle range single element of range [begin, ???);
        if(i == v.end())
            break;
        begin = i;
        // re-initialize next range
    }
}

对最后一个范围没有特殊处理——只是，可能需要两次初始化代码...

嵌套循环方法：

auto begin = v.begin();
for(;;)
{
    // initialize first/next range using *begin
    for(Iterator i = begin + 1; ; ++i)
    {
        if(i == v.end() || *i != *begin)
        {
            // handle range single element of range [begin, ???);
            if(i == v.end())
                goto LOOP_EXIT;
            begin = i;
            break;
        }
    }
}
LOOP_EXIT:
// go on
// if nothing left to do in function, we might prefer returning over going to...

更优雅？承认，我自己也很怀疑……不过，这两种方法都避免在同一范围内迭代两次（首先是为了找到终点，然后是实际的迭代）。如果我们从以下位置创建自己的库函数：

template <typename Iterator, typename RangeInitializer, typename ElementHandler>
void iterateOverEqualRanges
(
    Iterator begin, Iterator end,
    RangeInitializer ri, ElementHandler eh
)
{
    // the one of the two approaches you like better
    // or your own variation of...
}

然后我们可以像这样使用它：

std::vector<...> v;
iterateOverEqualRanges
(
    v.begin(), v.end(),
    [] (auto begin) { /* ... */ },
    [] (auto current) { /* ... */ }
);

最后，它看起来与 e 相似。 G。 std::for_each，不是吗？

Answer 6

for(auto b=v.begin(), i=b, e=v.end(); i!=e; b=i) {
    // initialise the 'Do something' code for another range
    for(; i!=e && *i==*b; ++i) {
        // Do something with i
    }
}