Ttdfjt

You can use std::upper_bound to get the iterator to the "next" value. Since std::upper_bound returns an iterator to the first element greater than that value provided, if you provide the value of the current element, it will give you an iterator that will be one past the end of the current value. That would give you a loop like

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

You are looking for std::equal_range.

Returns a range containing all elements equivalent to value in the
range [first, last).

Something like the following should work.

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

^{Remark: Even though this will be an intuitive approach, the std::equal_range obtains its first and second iterators(i.e b and e) with the help of std::lower_bound and std::upper_bound, which makes this approche slightly inefficient. Since, the first iterator could be easily accessible for the OP's case, calling std::upper_bound for second iterator only neccesarry(as shown by @NathanOliver 's answer).}

If your ranges of equal values is short, then std::adjacent_find would work well:

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) 

 

You can also substitute a lambda for std::not_equal_to if you wish.

But even if we don't use e for anything, this formulation is convenient, it's harder to make an error. The other way (to check for changing values) is more tedious (as we need to handle the last range specially [...])

Depends on how you interpret 'handling last range specially':

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

No special handling for last range – solely, possibly needing the initialization code twice...

Nested-loop-approach:

auto begin = v.begin();
for(;;)

 // initialize first/next range using *begin
 for(Iterator i = begin + 1; ; ++i)
 

LOOP_EXIT:
// go on
// if nothing left to do in function, we might prefer returning over going to...

More elegant? Admitted, I'm in doubt myself... Both approaches avoid iterating over the same range twice (first for finding the end, then the actual iteration), though. And if we make our own library function from:

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...

we could then use it like:

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

Now finally, it looks similiar to e. g. std::for_each, doesn't it?

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