Why does not std::advance return the resulting iterator?

Question

Currently, std::advance is designed like this:

template< class InputIt, class Distance >
void advance( InputIt& it, Distance n );

However, I frequently find myself want something like:

template< class InputIt, class Distance >
InputIt advance( InputIt it, Distance n );

So, what is the rationale behind the current design? Is this for some performance consideration? Note that std::next and std::prev do return the resulting iterator.

Answer 1

There is no technical reason preventing it to return a reference to the input value, and any reasonable compiler should be able to optimize the return value out if it's not used. So they could have done it that way if they wanted to.

I think their choice makes sense from an API design point of view though - std::prev and std::next take an iterator and return a different iterator pointing to the previous or next element, respectively, without modifying the input.

std::advance on the other hand modifies the input. If it returned a reference to the input iterator, it might be confused for a function that returns a copy without modifying the input in-place. That could potentially be dangerous.

Note that std::advance works with InputIterators, which includes iterators where iteration has side effects (things such as iterators that read from streams), but std::prev and std::next only work with ForwardIterators, which do not have side effects.

So returning a separate value (like std::prev and std::next) would be a bad idea - you'd end up with two iterators on the same stream, which may affect each other adversely.