What's the difference between std::advance and

问题:

Is there more beyond advance takes negative numbers?

回答1:

std::advance

• modifies its argument
• returns nothing
• works on input iterators or better (or bi-directional iterators if a negative distance is given)

std::next

• leaves its argument unmodified
• returns a copy of the argument, advanced by the specified amount
• works on forward iterators or better (or bi-directional iterators if a negative distance is given))

回答2:

Perhaps the biggest practical difference is that std::next() is only available in C++11.

std::next() will advance by one by default, whereas std::advance() requires a distance.

And then there are the return values:

• std::advance(): (none) (the iterator passed in is modified)
• std::next(): The n th successor.

std::next() takes negative numbers just like std::advance, and in that case requires that the iterator must be bidirectional. std::prev() would be more readable when the intent is specifically to move backwards.

回答3:

std::advance

The function advance() increments the position of an iterator passed as the argument. Thus, the function lets the iterator step forward (or backward) more than one element:

#include <iterator>
void advance (InputIterator& pos, Dist n)

• Lets the input iterator pos step n elements forward (or backward).
• For bidirectional and random-access iterators, n may be negative to step backward.
• Dist is a template type. Normally, it must be an integral type because operations such as <, ++, --, and comparisons with 0 are called.
• Note that advance() does not check whether it crosses the end() of a sequence (it can’t check because iterators in general do not know the containers on which they operate). Thus, calling this function might result in undefined behavior because calling operator ++ for the end of a sequence is not defined.

std::next(and std::prev new in C++11)

#include <iterator>
ForwardIterator next (ForwardIterator pos)
ForwardIterator next (ForwardIterator pos, Dist n)

• Yields the position the forward iterator pos would have if moved forward 1 or n positions.
• For bidirectional and random-access iterators, n may be negative to yield previous ositions.
• Dist is type std::iterator_traits::difference_type.
• Calls advance(pos,n) for an internal temporary object.
• Note that next() does not check whether it crosses the end() of a sequence. Thus, it is up to the caller to ensure that the result is valid.

cite from The C++ Standard Library Second Edition

回答4:

They're pretty much the same, except that std::next returns a copy and std::advance modifies its argument. Note that the standard requires std::next to behave like std::advance:

24.4.4 Iterator operations [iterator.operations]

template <class InputIterator, class Distance>
void advance(InputIterator& i [remark: reference], Distance n);

2. Requires: n shall be negative only for bidirectional and random access iterators
3. Effects: Increments (or decrements for negative n) iterator reference i by n.
[...]

template <class ForwardIterator>
ForwardIterator next(ForwardIterator x, [remark: copy]
     typename std::iterator_traits<ForwardIterator>::difference_type n = 1);

6. Effects: Equivalent to advance(x, n); return x;

Note that both actually support negative values if the iterator is an input iterator. Also note that std::next requires the iterator to meet the conditions of an ForwardIterator, while std::advance only needs an Input Iterator (if you don't use negative distances).