Experimentelle Bibliotheks-Header <experimental/ranges/iterator>

 

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

 

Header der Standardbibliothek

Sprachunterstützung <cfloat> <climits> <compare> (C++20) <contracts> (C++26) <coroutine> (C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint> (C++11) <cstdlib> <exception> <initializer_list> (C++11)    <limits> <new> <source_location> (C++20) <stdfloat> (C++23) <typeinfo> <version> (C++20) Konzepte <concepts> (C++20) Diagnose <cassert> <cerrno> <debugging> (C++26) <stacktrace> (C++23) <stdexcept> <system_error> (C++11) Speicherverwaltung <memory> <memory_resource> (C++17) <scoped_allocator> (C++11) Metaprogrammierung <type_traits> (C++11) <ratio> (C++11)

Allgemeine Hilfsmittel <any> (C++17) <bitset> <bit> (C++20) <charconv> (C++17) <expected> (C++23) <format> (C++20) <functional> <optional> (C++17) <tuple> (C++11) <typeindex> (C++11) <utility> <variant> (C++17) Container <array> (C++11) <deque> <flat_map> (C++23) <flat_set> (C++23) <forward_list> (C++11) <hive> (C++26) <inplace_vector> (C++26)    <list> <map> <mdspan> (C++23) <queue> <set> <span> (C++20) <stack> <unordered_map> (C++11) <unordered_set> (C++11) <vector> Iteratoren <iterator> Bereiche (Ranges) <generator> (C++23) <ranges> (C++20)

Algorithmen <algorithm> <numeric> Strings <cctype> <cstring> <cuchar> (C++11) <cwchar> <cwctype> <string_view> (C++17) <string> Textverarbeitung <clocale> <codecvt> (C++11/17/26*) <locale> <regex> (C++11) <text_encoding> (C++26)    Numerik <cfenv> (C++11) <cmath> <complex> <linalg> (C++26) <numbers> (C++20) <random> (C++11) <simd> (C++26) <valarray> Zeit <chrono> (C++11) <ctime> C Kompatibilität <ccomplex> (C++11/17/20*) <ciso646> (bis C++20) <cstdalign> (C++11/17/20*) <cstdbool> (C++11/17/20*) <ctgmath> (C++11/17/20*)

Ein-/Ausgabe <cinttypes> (C++11) <cstdio> <filesystem> (C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print> (C++23) <spanstream> (C++23) <sstream> <streambuf> <strstream> (C++98/26*) <syncstream> (C++20) Nebenläufigkeitsunterstützung <atomic> (C++11) <barrier> (C++20) <condition_variable> (C++11) <future> (C++11) <hazard_pointer> (C++26) <latch> (C++20) <mutex> (C++11) <rcu> (C++26) <semaphore> (C++20) <shared_mutex> (C++14) <stdatomic.h> (C++23) <stop_token> (C++20) <thread> (C++11) Ausführungshilfe <execution> (C++17)

 

Experimentelle Bibliotheks-Header

Ausführung P2300
<experimental/execution>
Filesystem TS
<experimental/filesystem>
Parallelism TS (v1, v2)
experimental/algorithm experimental/execution_policy experimental/exception_list	experimental/numeric <experimental/simd> experimental/task_block
Library Fundamentals TS (v1, v2, v3)
experimental/algorithm <experimental/any> experimental/array experimental/chrono experimental/deque experimental/forward_list <experimental/functional> experimental/future experimental/iterator experimental/list experimental/map experimental/memory <experimental/memory_resource> experimental/numeric <experimental/optional> experimental/propagate_const	experimental/random experimental/ratio experimental/regex experimental/scope experimental/set experimental/source_location experimental/string <experimental/string_view> experimental/system_error experimental/tuple experimental/type_traits experimental/unordered_map experimental/unordered_set experimental/utility experimental/vector
Concurrency TS
experimental/atomic experimental/barrier	experimental/future experimental/latch
Ranges TS
<experimental/ranges/algorithm> <experimental/ranges/concepts> <experimental/ranges/functional>         <experimental/ranges/iterator>	<experimental/ranges/random> <experimental/ranges/tuple> <experimental/ranges/type_traits> <experimental/ranges/utility>
Coroutines TS
experimental/coroutine
Networking TS
experimental/buffer experimental/executor experimental/internet experimental/io_context	<experimental/net> experimental/netfwd experimental/socket experimental/timer
Reflection TS
<experimental/reflect>

 

Dieser Header ist Teil der ranges Bibliothek.

Iteratorbezogene Konzepte

Definiert im Namespace std::experimental::ranges

Iterator-Konzepte

Readable	spezifiziert, dass ein Typ durch Anwenden des Operators * lesbar ist (concept)
Writable	spezifiziert, dass ein Wert in das von einem Iterator referenzierte Objekt geschrieben werden kann (concept)
WeaklyIncrementable	spezifiziert, dass ein Semiregular-Typ mit Prä- und Post-Inkrement-Operatoren inkrementiert werden kann (concept)
Incrementable	gibt an, dass die Inkrementoperation auf einem Typ WeaklyIncrementable gleichheitserhaltend ist und dass der Typ EqualityComparable ist (concept)
Iterator	spezifiziert, dass Objekte eines Typs inkrementiert und dereferenziert werden können (concept)
Sentinel	gibt an, dass Objekte eines Typs ein Sentinel für einen Iterator-Typ sind (concept)
SizedSentinel	gibt an, dass der Operator - auf einen Iterator und ein Sentinel angewendet werden kann, um deren Differenz in konstanter Zeit zu berechnen (concept)
InputIterator	spezifiziert, dass ein Typ ein Eingabeiterator ist, d. h. seine referenzierten Werte können gelesen werden und er kann sowohl prä- als auch post-inkrementiert werden (concept)
OutputIterator	spezifiziert, dass ein Typ ein Ausgabeiterator für einen gegebenen Werttyp ist, d. h. Werte dieses Typs können hineingeschrieben werden und er kann sowohl prä- als auch post-inkrementiert werden (concept)
ForwardIterator	gibt an, dass ein InputIterator ein Vorwärtsiterator ist, der Gleichheitsvergleiche und Mehrfachdurchläufe unterstützt (concept)
BidirectionalIterator	gibt an, dass ein ForwardIterator ein bidirektionaler Iterator ist, der die Rückwärtsbewegung unterstützt (concept)
RandomAccessIterator	gibt an, dass ein BidirectionalIterator ein Zufallszugriffsiterator ist, der die Unterstützung für die Vorwärtsbewegung in konstanter Zeit und Subskription bietet (concept)

Indirekt aufrufbare Konzepte

IndirectUnaryInvocableIndirectRegularUnaryInvocable	gibt an, dass ein aufrufbarer Typ mit dem Ergebnis der Dereferenzierung eines Readable-Typs aufgerufen werden kann (concept)
IndirectUnaryPredicate	gibt an, dass ein aufrufbares Objekt, wenn es mit dem Ergebnis der Dereferenzierung eines Readable-Typs aufgerufen wird, Predicate erfüllt (concept)
IndirectRelation	gibt an, dass ein aufrufbares Objekt, wenn es mit dem Ergebnis der Dereferenzierung einiger Readable-Typen aufgerufen wird, Relation erfüllt (concept)
IndirectStrictWeakOrder	gibt an, dass ein aufrufbares Objekt, wenn es mit dem Ergebnis der Dereferenzierung einiger Readable-Typen aufgerufen wird, StrictWeakOrder erfüllt (concept)

Gemeinsame Algorithmus-Anforderungen

IndirectlyMovable	gibt an, dass Werte von einem Readable-Typ zu einem Writable-Typ verschoben werden können (concept)
IndirectlyMovableStorable	gibt an, dass Werte von einem Readable-Typ zu einem Writable-Typ verschoben werden können und dass die Verschiebung über ein Zwischenobjekt erfolgen kann (concept)
IndirectlyCopyable	gibt an, dass Werte von einem Readable-Typ zu einem Writable-Typ kopiert werden können (concept)
IndirectlyCopyableStorable	gibt an, dass Werte von einem Readable-Typ zu einem Writable-Typ kopiert werden können und dass die Kopie über ein Zwischenobjekt erfolgen kann (concept)
IndirectlySwappable	gibt an, dass die von zwei Readable-Typen referenzierten Werte vertauscht werden können (concept)
IndirectlyComparable	gibt an, dass die von zwei Readable-Typen referenzierten Werte verglichen werden können (concept)
Permutable	spezifiziert die gemeinsamen Anforderungen für Algorithmen, die Elemente an Ort und Stelle neu ordnen (concept)
Mergeable	spezifiziert die Anforderungen für Algorithmen, die sortierte Sequenzen durch Kopieren von Elementen zu einer Ausgabesequenz zusammenführen (concept)
Sortable	spezifiziert die gemeinsamen Anforderungen für Algorithmen, die Sequenzen zu sortierten Sequenzen permutieren (concept)

Konzept-Dienstprogramme

indirect_result_of	berechnet das Ergebnis des Aufrufs eines aufrufbaren Objekts auf dem Ergebnis der Dereferenzierung einer Menge von Readable-Typen (class template)
projected	Hilfsvorlage zur Spezifizierung der Einschränkungen für Algorithmen, die Projektionen akzeptieren (class template)

Iterator-Primitive

Iterator-Dienstprogramme

Definiert im Namespace std::experimental::ranges
iter_move	wandelt das Ergebnis der Dereferenzierung eines Objekts in seinen zugehörigen rvalue-Referenztyp um (customization point object)
iter_swap	tauscht die Werte, auf die von zwei dereferenzierbaren Objekten verwiesen wird (customization point object)

Iterator-Traits

Definiert im Namespace std::experimental::ranges
difference_type	ermittelt den Differenztyp eines WeaklyIncrementable-Typs (class template)
value_type	ermittelt den Werttyp eines Readable-Typs (class template)
iterator_category	ermittelt die Iterator-Kategorie eines Eingabeiterator-Typs (class template)
iterator_traits	Kompatibilitäts-Traits-Klasse, die die zugehörigen Typen eines Iterators sammelt (Alias-Vorlage)
reference_trvalue_reference_titer_common_reference_t	ermittelt die assoziierten Referenztypen eines dereferenzierbaren Objekts (alias template)

Iterator-Kategorie-Tags

Definiert im Namespace std::experimental::ranges
input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tag	leere Klassentypen, die zur Angabe von Iterator-Kategorien verwendet werden (Klasse)

std::iterator_traits-Spezialisierungen

Definiert im Namespace std
std::iterator_traits<InputIterator>std::iterator_traits<OutputIterator>	spezialisiert std::iterator_traits für Ranges-TS-Iteratoren (class template specialization)

Iterator-Operationen

Definiert im Namespace std::experimental::ranges
advance	bewegt einen Iterator um die angegebene Distanz vorwärts (Funktionsvorlage)
distance	gibt die Distanz zwischen einem Iterator und einem Sentinel zurück, oder zwischen dem Anfang und dem Ende eines Bereichs (Funktionsvorlage)
next	inkrementiert einen Iterator (Funktionsvorlage)
prev	dekrementiert einen Iterator (Funktionsvorlage)

Iterator-Adapter

Definiert im Namespace std::experimental::ranges
reverse_iterator	Iterator-Adapter für die Rückwärtsiteration (class template)
back_insert_iterator	Iterator-Adapter für die Einfügung am Ende eines Containers (class template)
front_insert_iterator	Iterator-Adapter für die Einfügung am Anfang eines Containers (class template)
insert_iterator	Iterator-Adapter für die Einfügung in einen Container (class template)
move_iterator	Iterator-Adapter, der zu einer rvalue-Referenz dereferenziert (class template)
move_sentinel	Sentinel-Adapter zur Verwendung mit move_iterator (class template)
common_iterator	passt ein Iterator-Sentinel-Paar an einen gemeinsamen Iterator-Typ für die Verwendung mit Legacy-Algorithmen an (class template)
counted_iterator	Iterator-Adapter, der seinen Abstand von seiner Startposition verfolgt (class template)
default_sentinel	leerer Sentinel-Typ zur Verwendung mit Iterator-Typen, die die Grenze ihres Bereichs kennen (class)
dangling	Wrapper für einen möglicherweise hängenden Iterator (class template)
safe_iterator_t	Alias-Vorlage, die den Iterator-Typ eines rvalue-Bereichs mit dangling umschließt (alias template)
unreachable	Sentinel-Typ, der mit jedem Iterator verwendet wird, um einen unendlichen Bereich zu bezeichnen (class)

Stream-Iteratoren

Definiert im Namespace std::experimental::ranges
istream_iterator	Eingabe-Iterator, der aus std::basic_istream liest (class template)
ostream_iterator	Ausgabe-Iterator, der in std::basic_ostream schreibt (class template)
istreambuf_iterator	Eingabe-Iterator, der aus std::basic_streambuf liest (class template)
ostreambuf_iterator	Ausgabe-Iterator, der in std::basic_streambuf schreibt (class template)

Synopsis

namespace std { namespace experimental { namespace ranges { inline namespace v1 {
 
template <class T> concept bool /* dereferenceable */ // exposition only
  = requires(T& t) { {*t} -> auto&&; };
 
namespace {
  constexpr /* unspecified */ iter_move = /* unspecified */;
  constexpr /* unspecified */ iter_swap = /* unspecified */;
}
 
template <class> struct difference_type;
template <class T> using difference_type_t
  = typename difference_type<T>::type;
 
template <class> struct value_type;
template <class T> using value_type_t
  = typename value_type<T>::type;
 
template <class> struct iterator_category;
template <class T> using iterator_category_t
  = typename iterator_category<T>::type;
 
template </* dereferenceable */ T> using reference_t
  = decltype(*declval<T&>());
 
template </* dereferenceable */ T>
    requires /* see definition */ using rvalue_reference_t
  = decltype(ranges::iter_move(declval<T&>()));
 
template <class In>
concept bool Readable = /* see definition */;
 
template <class Out, class T>
concept bool Writable = /* see definition */;
 
template <class I>
concept bool WeaklyIncrementable = /* see definition */;
 
template <class I>
concept bool Incrementable = /* see definition */;
 
template <class I>
concept bool Iterator = /* see definition */;
 
template <class S, class I>
concept bool Sentinel = /* see definition */;
 
template <class S, class I>
  constexpr bool disable_sized_sentinel = false;
 
template <class S, class I>
concept bool SizedSentinel = /* see definition */;
 
template <class I>
concept bool InputIterator = /* see definition */;
 
template <class I>
concept bool OutputIterator = /* see definition */;
 
template <class I>
concept bool ForwardIterator = /* see definition */;
 
template <class I>
concept bool BidirectionalIterator = /* see definition */;
 
template <class I>
concept bool RandomAccessIterator = /* see definition */;
 
template <class F, class I>
concept bool IndirectUnaryInvocable = /* see definition */;
 
template <class F, class I>
concept bool IndirectRegularUnaryInvocable = /* see definition */;
 
template <class F, class I>
concept bool IndirectUnaryPredicate = /* see definition */;
 
template <class F, class I1, class I2 = I1>
concept bool IndirectRelation = /* see definition */;
 
template <class F, class I1, class I2 = I1>
concept bool IndirectStrictWeakOrder = /* see definition */;
 
template <class> struct indirect_result_of;
 
template <class F, class... Is>
  requires Invocable<F, reference_t<Is>...>
struct indirect_result_of<F(Is...)>;
 
template <class F>
using indirect_result_of_t
  = typename indirect_result_of<F>::type;
 
template <Readable I, IndirectRegularUnaryInvocable<I> Proj>
struct projected;
 
template <WeaklyIncrementable I, class Proj>
struct difference_type<projected<I, Proj>>;
 
template <class In, class Out>
concept bool IndirectlyMovable = /* see definition */;
 
template <class In, class Out>
concept bool IndirectlyMovableStorable = /* see definition */;
 
template <class In, class Out>
concept bool IndirectlyCopyable = /* see definition */;
 
template <class In, class Out>
concept bool IndirectlyCopyableStorable = /* see definition */;
 
template <class I1, class I2 = I1>
concept bool IndirectlySwappable = /* see definition */;
 
template <class I1, class I2, class R = equal_to<>, class P1 = identity,
    class P2 = identity>
concept bool IndirectlyComparable = /* see definition */;
 
template <class I>
concept bool Permutable = /* see definition */;
 
template <class I1, class I2, class Out,
    class R = less<>, class P1 = identity, class P2 = identity>
concept bool Mergeable = /* see definition */;
 
template <class I, class R = less<>, class P = identity>
concept bool Sortable = /* see definition */;
 
template <class Iterator> using iterator_traits = /* see definition */;
 
template <Readable T> using iter_common_reference_t
  = common_reference_t<reference_t<T>, value_type_t<T>&>;
 
struct output_iterator_tag { };
struct input_iterator_tag { };
struct forward_iterator_tag : input_iterator_tag { };
struct bidirectional_iterator_tag : forward_iterator_tag { };
struct random_access_iterator_tag : bidirectional_iterator_tag { };
 
namespace {
  constexpr /* unspecified */ advance = /* unspecified */;
  constexpr /* unspecified */ distance = /* unspecified */;
  constexpr /* unspecified */ next = /* unspecified */;
  constexpr /* unspecified */ prev = /* unspecified */;
}
 
template <BidirectionalIterator I> class reverse_iterator;
 
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator==(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator!=(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>=(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<=(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
 
template <class I1, class I2>
    requires SizedSentinel<I1, I2>
  constexpr difference_type_t<I2> operator-(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <RandomAccessIterator I>
  constexpr reverse_iterator<I> operator+(
    difference_type_t<I> n,
    const reverse_iterator<I>& x);
 
template <BidirectionalIterator I>
constexpr reverse_iterator<I> make_reverse_iterator(I i);
 
template <class Container> class back_insert_iterator;
template <class Container>
  back_insert_iterator<Container> back_inserter(Container& x);
 
template <class Container> class front_insert_iterator;
template <class Container>
  front_insert_iterator<Container> front_inserter(Container& x);
 
template <class Container> class insert_iterator;
template <class Container>
  insert_iterator<Container> inserter(Container& x, iterator_t<Container> i);
 
template <InputIterator I> class move_iterator;
 
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator==(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator!=(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<=(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>=(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
 
template <class I1, class I2>
    requires SizedSentinel<I1, I2>
  constexpr difference_type_t<I2> operator-(
    const move_iterator<I1>& x,
    const move_iterator<I2>& y);
template <RandomAccessIterator I>
  constexpr move_iterator<I> operator+(
    difference_type_t<I> n,
    const move_iterator<I>& x);
 
template <InputIterator I>
  constexpr move_iterator<I> make_move_iterator(I i);
 
template <Semiregular S> class move_sentinel;
 
template <class I, Sentinel<I> S>
  constexpr bool operator==(
    const move_iterator<I>& i, const move_sentinel<S>& s);
template <class I, Sentinel<I> S>
  constexpr bool operator==(
    const move_sentinel<S>& s, const move_iterator<I>& i);
template <class I, Sentinel<I> S>
  constexpr bool operator!=(
    const move_iterator<I>& i, const move_sentinel<S>& s);
template <class I, Sentinel<I> S>
  constexpr bool operator!=(
    const move_sentinel<S>& s, const move_iterator<I>& i);
 
template <class I, SizedSentinel<I> S>
  constexpr difference_type_t<I> operator-(
    const move_sentinel<S>& s, const move_iterator<I>& i);
template <class I, SizedSentinel<I> S>
  constexpr difference_type_t<I> operator-(
    const move_iterator<I>& i, const move_sentinel<S>& s);
 
template <Semiregular S>
  constexpr move_sentinel<S> make_move_sentinel(S s);
 
template <Iterator I, Sentinel<I> S>
  requires !Same<I, S>
class common_iterator;
 
template <Readable I, class S>
struct value_type<common_iterator<I, S>>;
 
template <InputIterator I, class S>
struct iterator_category<common_iterator<I, S>>;
 
template <ForwardIterator I, class S>
struct iterator_category<common_iterator<I, S>>;
 
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
bool operator==(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
  requires EqualityComparableWith<I1, I2>
bool operator==(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
bool operator!=(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
 
template <class I2, SizedSentinel<I2> I1, SizedSentinel<I2> S1, SizedSentinel<I1> S2>
difference_type_t<I2> operator-(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
 
class default_sentinel;
 
template <Iterator I> class counted_iterator;
 
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator==(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
constexpr bool operator==(
  const counted_iterator<auto>& x, default_sentinel);
constexpr bool operator==(
  default_sentinel, const counted_iterator<auto>& x);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator!=(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
constexpr bool operator!=(
  const counted_iterator<auto>& x, default_sentinel y);
constexpr bool operator!=(
  default_sentinel x, const counted_iterator<auto>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator<(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator<=(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator>(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator>=(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
 
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr difference_type_t<I2> operator-(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I>
  constexpr difference_type_t<I> operator-(
    const counted_iterator<I>& x, default_sentinel y);
template <class I>
  constexpr difference_type_t<I> operator-(
    default_sentinel x, const counted_iterator<I>& y);
template <RandomAccessIterator I>
  constexpr counted_iterator<I>
    operator+(difference_type_t<I> n, const counted_iterator<I>& x);
 
template <Iterator I>
  constexpr counted_iterator<I> make_counted_iterator(I i, difference_type_t<I> n);
 
class unreachable;
template <Iterator I>
  constexpr bool operator==(const I&, unreachable) noexcept;
template <Iterator I>
  constexpr bool operator==(unreachable, const I&) noexcept;
template <Iterator I>
  constexpr bool operator!=(const I&, unreachable) noexcept;
template <Iterator I>
  constexpr bool operator!=(unreachable, const I&) noexcept;
 
template <class T> class dangling;
 
template <class T, class CharT = char, class Traits = char_traits<CharT>,
    class Distance = ptrdiff_t>
  class istream_iterator;
 
template <class T, class CharT, class Traits, class Distance>
  bool operator==(const istream_iterator<T, CharT, Traits, Distance>& x,
    const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
  bool operator==(default_sentinel x,
    const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
  bool operator==(const istream_iterator<T, CharT, Traits, Distance>& x,
    default_sentinel y);
template <class T, class CharT, class Traits, class Distance>
  bool operator!=(const istream_iterator<T, CharT, Traits, Distance>& x,
    const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
  bool operator!=(default_sentinel x,
    const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
  bool operator!=(const istream_iterator<T, CharT, Traits, Distance>& x,
    default_sentinel y);
 
template <class T, class CharT = char, class Traits = char_traits<CharT>>
  class ostream_iterator;
 
template <class CharT, class Traits = char_traits<CharT> >
  class istreambuf_iterator;
 
template <class CharT, class Traits>
  bool operator==(const istreambuf_iterator<CharT, Traits>& a,
    const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
  bool operator==(default_sentinel a,
    const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
  bool operator==(const istreambuf_iterator<CharT, Traits>& a,
    default_sentinel b);
template <class CharT, class Traits>
  bool operator!=(const istreambuf_iterator<CharT, Traits>& a,
    const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
  bool operator!=(default_sentinel a,
    const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
  bool operator!=(const istreambuf_iterator<CharT, Traits>& a,
    default_sentinel b);
 
template <class CharT, class Traits = char_traits<CharT> >
  class ostreambuf_iterator;
 
}}}}
 
namespace std {
  template <experimental::ranges::Iterator Out>
    struct iterator_traits<Out>;
  template <experimental::ranges::InputIterator In>
    struct iterator_traits<In>;
  template <experimental::ranges::InputIterator In>
      requires experimental::ranges::Sentinel<In, In>
    struct iterator_traits;
}