std::ranges::advance

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Iterator-Bibliothek

Iterator-Konzepte
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-Primitive
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 (veraltet in C++17) iterator_traits incrementable_traits (C++20) indirectly_readable_traits (C++20)
Algorithmus-Konzepte und Hilfsprogramme
Indirekte aufrufbare Konzepte
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)
Gemeinsame Algorithmus-Anforderungen
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)
Dienstprogramme
indirect_result_t (C++20)	projected (C++20)	projected_value_t (C++26)
Iterator-Adapter
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-Iteratoren istream_iterator    ostream_iterator istreambuf_iterator ostreambuf_iterator	Iterator-Anpassungspunkte ranges::iter_move (C++20) ranges::iter_swap (C++20)
Iterator-Operationen advance distance prev (C++11)   next (C++11) ranges::advance (C++20) ranges::distance (C++20) ranges::prev (C++20) ranges::next (C++20)	Bereichszugriff 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)

 

Definiert in Header <iterator>
Aufruf-Signatur
template< std::input_or_output_iterator I > constexpr void advance( I& i, std::iter_difference_t<I> n );	(1)	(seit C++20)
template< std::input_or_output_iterator I, std::sentinel_for<I> S > constexpr void advance( I& i, S bound );	(2)	(seit C++20)
template< std::input_or_output_iterator I, std::sentinel_for<I> S > constexpr std::iter_difference_t<I> advance( I& i, std::iter_difference_t<I> n, S bound );	(3)	(seit C++20)

1) Inkrementiert den gegebenen Iterator i für n mal.

2) Inkrementiert den gegebenen Iterator i, bis i == bound.

3) Inkrementiert den gegebenen Iterator i für n mal oder bis i == bound, je nachdem, was zuerst eintritt.

Wenn n negativ ist, wird der Iterator dekrementiert. In diesem Fall muss I std::bidirectional_iterator modellieren und S muss vom gleichen Typ wie I sein, wenn bound angegeben ist, andernfalls ist das Verhalten undefiniert.

Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmus-Funktionsobjekte (informell als niebloids bekannt), d.h.

• Können explizite Template-Argumentlisten bei keinem von ihnen angegeben werden.
• Keiner von ihnen ist für Argument-abhängige Suche sichtbar.
• Wenn einer von ihnen durch normale unqualifizierte Suche als Name links vom Funktionsaufrufoperator gefunden wird, wird die Argument-abhängige Suche unterdrückt.

Parameter

i	-	Der zu verschiebende Iterator
bound	-	Sentinel, der das Ende des Bereichs bezeichnet, auf den i ein Iterator ist
n	-	Maximale Anzahl von Inkrementierungen von i

Rückgabewert

3) Die Differenz zwischen n und dem tatsächlich zurückgelegten Abstand von i.

Komplexität

Linear.

Wenn I zusätzlich std::random_access_iterator modelliert oder S std::sized_sentinel_for<I> modelliert oder I und S std::assignable_from<I&, S> modellieren, ist die Komplexität konstant.

Hinweise

Das Verhalten ist undefiniert, wenn die angegebene Sequenz von Inkrementierungen oder Dekrementierungen erfordert, dass ein nicht inkrementierbarer Iterator (wie z. B. ein Iterator hinter dem Ende) inkrementiert wird, oder dass ein nicht dekrementierbarer Iterator (wie z. B. ein Iterator am Anfang oder ein singulärer Iterator) dekrementiert wird.

Mögliche Implementierung

struct advance_fn { template<std::input_or_output_iterator I> constexpr void operator()(I& i, std::iter_difference_t<I> n) const { if constexpr (std::random_access_iterator<I>) i += n; else { while (n > 0) { --n; ++i; }   if constexpr (std::bidirectional_iterator<I>) { while (n < 0) { ++n; --i; } } } }   template<std::input_or_output_iterator I, std::sentinel_for<I> S> constexpr void operator()(I& i, S bound) const { if constexpr (std::assignable_from<I&, S>) i = std::move(bound); else if constexpr (std::sized_sentinel_for<S, I>) (*this)(i, bound - i); else while (i != bound) ++i; }   template<std::input_or_output_iterator I, std::sentinel_for<I> S> constexpr std::iter_difference_t<I> operator()(I& i, std::iter_difference_t<I> n, S bound) const { if constexpr (std::sized_sentinel_for<S, I>) { // std::abs is not constexpr until C++23 auto abs = [](const std::iter_difference_t<I> x) { return x < 0 ? -x : x; };   if (const auto dist = abs(n) - abs(bound - i); dist < 0) { (*this)(i, bound); return -dist; }   (*this)(i, n); return 0; } else { while (n > 0 && i != bound) { --n; ++i; }   if constexpr (std::bidirectional_iterator<I>) { while (n < 0 && i != bound) { ++n; --i; } }   return n; } } };   inline constexpr auto advance = advance_fn();

Beispiel

Führen Sie diesen Code aus

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

Ausgabe

1) value: 4
2) vi == v.end(): true
3) value: 3
4) diff: 0, value: 4
5) diff: 3, vi == v.end(): true

Siehe auch

ranges::next (C++20)	inkrementiert einen Iterator um eine gegebene Distanz oder zu einer Grenze (Algorithmus-Funktionsobjekt)
ranges::prev (C++20)	dekrementiert einen Iterator um eine gegebene Distanz oder zu einer Grenze (Algorithmus-Funktionsobjekt)
ranges::distance (C++20)	gibt die Distanz zwischen einem Iterator und einem Sentinel zurück oder die Distanz zwischen dem Anfang und dem Ende eines Bereichs (Algorithmus-Funktionsobjekt)
advance	bewegt einen Iterator um die angegebene Distanz vorwärts (Funktionsvorlage)