std::advance

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros(C++20)

Language support library

Concepts library(C++20)

Diagnostics library

Memory management library

Metaprogramming library(C++11)

General utilities library

Containers library

Iterators library

Ranges library(C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library(C++17)

Concurrency support library(C++11)

Execution control library(C++26)

Technical specifications

Symbols index

External libraries

 

Iterator library

Iterator concepts
indirectly_readable (C++20) indirectly_writable (C++20) weakly_incrementable (C++20) incrementable (C++20) is-integer-like is-signed-integer-like (C++20)(C++20)	sentinel_for (C++20) sized_sentinel_for (C++20) input_iterator (C++20) output_iterator (C++20) input_or_output_iterator (C++20)	forward_iterator (C++20) bidirectional_iterator (C++20) random_access_iterator (C++20) contiguous_iterator (C++20)
Iterator primitives
input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tagcontiguous_iterator_tag (C++20)	iter_value_titer_difference_titer_reference_titer_const_reference_titer_rvalue_reference_titer_common_reference_t (C++20)(C++20)(C++20)(C++23)(C++20)(C++20)	iterator (deprecated in C++17) iterator_traits incrementable_traits (C++20) indirectly_readable_traits (C++20)
Algorithm concepts and utilities
Indirect callable concepts
indirectly_unary_invocableindirectly_regular_unary_invocable (C++20)(C++20)	indirect_unary_predicate (C++20) indirect_binary_predicate (C++20)	indirect_equivalence_relation (C++20) indirect_strict_weak_order (C++20)
Common algorithm requirements
indirectly_movable (C++20) indirectly_movable_storable (C++20) indirectly_copyable (C++20)	indirectly_copyable_storable (C++20)   indirectly_swappable (C++20) indirectly_comparable (C++20)	permutable (C++20) mergeable (C++20) sortable (C++20)
Utilities
indirect_result_t (C++20)	projected (C++20)	projected_value_t (C++26)
Iterator adaptors
reverse_iterator make_reverse_iterator (C++14) move_iterator (C++11) make_move_iterator (C++11) default_sentinel_tdefault_sentinel (C++20)(C++20) unreachable_sentinel_tunreachable_sentinel (C++20)(C++20)	front_insert_iterator back_insert_iterator inserter insert_iterator front_inserter back_inserter move_sentinel (C++20)	common_iterator (C++20) counted_iterator (C++20) basic_const_iterator (C++23) const_iterator (C++23) const_sentinel (C++23) make_const_iterator (C++23) make_const_sentinel (C++23)
Stream iterators istream_iterator    ostream_iterator istreambuf_iterator ostreambuf_iterator	Iterator customization points ranges::iter_move (C++20) ranges::iter_swap (C++20)
Iterator operations advance distance prev (C++11)   next (C++11) ranges::advance (C++20) ranges::distance (C++20) ranges::prev (C++20) ranges::next (C++20)	Range access begincbegin (C++11)(C++14) rbegincrbegin (C++14)(C++14)   endcend (C++11)(C++14) rendcrend (C++14)(C++14)   sizessize (C++17)(C++20) empty (C++17) data (C++17)

 

Defined in header <iterator>
template<class InputIt, class Distance > void advance( InputIt& it, Distance n );		(until C++17)
template<class InputIt, class Distance > constexprvoid advance( InputIt& it, Distance n );		(since C++17)

Increments given iterator it by n elements.

If n is negative, the iterator is decremented. In this case, InputIt must meet the requirements of LegacyBidirectionalIterator, otherwise the behavior is undefined.

Parameters

it	-	iterator to be advanced
n	-	number of elements it should be advanced
Type requirements
- InputIt must meet the requirements of LegacyInputIterator.

Return value

(none)

Complexity

Linear.

However, if InputIt additionally meets the requirements of LegacyRandomAccessIterator, complexity is constant.

Notes

The behavior is undefined if the specified sequence of increments or decrements would require that a non-incrementable iterator (such as the past-the-end iterator) is incremented, or that a non-decrementable iterator (such as the front iterator or the singular iterator) is decremented.

Possible implementation

See also the implementations in libstdc++ and libc++.

Non-constexpr version
namespace detail {template<class It>void do_advance(It& it, typenamestd::iterator_traits<It>::difference_type n, std::input_iterator_tag){while(n >0){--n;++it;}}   template<class It>void do_advance(It& it, typenamestd::iterator_traits<It>::difference_type n, std::bidirectional_iterator_tag){while(n >0){--n;++it;}while(n <0){++n;--it;}}   template<class It>void do_advance(It& it, typenamestd::iterator_traits<It>::difference_type n, std::random_access_iterator_tag){ it += n;}}// namespace detail   template<class It, class Distance>void advance(It& it, Distance n){ detail::do_advance(it, typenamestd::iterator_traits<It>::difference_type(n), typenamestd::iterator_traits<It>::iterator_category());}
constexpr version
template<class It, class Distance>constexprvoid advance(It& it, Distance n){using category =typenamestd::iterator_traits<It>::iterator_category; static_assert(std::is_base_of_v<std::input_iterator_tag, category>);   auto dist =typenamestd::iterator_traits<It>::difference_type(n);ifconstexpr(std::is_base_of_v<std::random_access_iterator_tag, category>) it += dist;else{while(dist >0){--dist;++it;}ifconstexpr(std::is_base_of_v<std::bidirectional_iterator_tag, category>)while(dist <0){++dist;--it;}}}

Example

Run this code

#include <iostream>#include <iterator>#include <vector>   int main(){std::vector<int> v{3, 1, 4};   auto vi = v.begin(); std::advance(vi, 2);std::cout<<*vi <<' ';   vi = v.end(); std::advance(vi, -2);std::cout<<*vi <<'\n';}

Output:

4 1

See also

next (C++11)	increment an iterator (function template)
prev (C++11)	decrement an iterator (function template)
distance	returns the distance between two iterators (function template)
ranges::advance (C++20)	advances an iterator by given distance or to a given bound (algorithm function object)