Experimental library header <experimental/ranges/iterator>

From cppreference.net

<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.

Inhaltsverzeichnis

Iterator-bezogene Konzepte

Definiert in Namespace


           std::experimental::ranges

Iterator-Konzepte

Readable	spezifiziert, dass ein Typ durch Anwendung des Operators `*` lesbar ist (Konzept)
Writable	spezifiziert, dass ein Wert in das referenzierte Objekt eines Iterators geschrieben werden kann (Konzept)
WeaklyIncrementable	spezifiziert, dass ein `Semiregular` Typ mit Prä- und Post-Inkrementoperatoren inkrementiert werden kann (Konzept)
Incrementable	spezifiziert, dass die Inkrementoperation auf einem `WeaklyIncrementable` Typ gleichheitserhaltend ist und dass der Typ `EqualityComparable` ist (Konzept)
Iterator	spezifiziert, dass Objekte eines Typs inkrementiert und dereferenziert werden können (Konzept)
Sentinel	spezifiziert, dass Objekte eines Typs ein Sentinel für einen `Iterator` Typ sind (Konzept)
SizedSentinel	spezifiziert, dass der `-` Operator auf einen Iterator und einen Sentinel angewendet werden kann, um ihre Differenz in konstanter Zeit zu berechnen (Konzept)
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 (Konzept)
OutputIterator	spezifiziert, dass ein Typ ein Ausgabeiterator für einen gegebenen Werttyp ist, d.h. Werte dieses Typs können in ihn geschrieben werden und er kann sowohl prä- als auch post-inkrementiert werden (Konzept)
ForwardIterator	spezifiziert, dass ein `InputIterator` ein Vorwärtsiterator ist, der Gleichheitsvergleiche und Mehrfachdurchläufe unterstützt (Konzept)
BidirectionalIterator	spezifiziert, dass ein `ForwardIterator` ein bidirektionaler Iterator ist, der Bewegung rückwärts unterstützt (Konzept)
RandomAccessIterator	spezifiziert, dass ein `BidirectionalIterator` ein wahlfreier Zugriffsiterator ist, der Fortbewegung in konstanter Zeit und Indizierung unterstützt (Konzept)

Indirekte aufrufbare Konzepte

IndirectUnaryInvocable IndirectRegularUnaryInvocable	spezifiziert, dass ein aufrufbarer Typ mit dem Ergebnis der Dereferenzierung eines `Readable` Typs aufgerufen werden kann (Konzept)
IndirectUnaryPredicate	spezifiziert, dass ein aufrufbares Objekt, wenn es mit dem Ergebnis der Dereferenzierung eines `Readable` Typs aufgerufen wird, `Predicate` erfüllt (Konzept)
IndirectRelation	spezifiziert, dass ein aufrufbares Objekt, wenn es mit dem Ergebnis der Dereferenzierung einiger `Readable` Typen aufgerufen wird, `Relation` erfüllt (Konzept)
IndirectStrictWeakOrder	spezifiziert, dass ein aufrufbares Objekt, wenn es mit dem Ergebnis der Dereferenzierung einiger `Readable` Typen aufgerufen wird, `StrictWeakOrder` erfüllt (Konzept)

Allgemeine Algorithmusanforderungen

IndirectlyMovable	spezifiziert, dass Werte von einem `Readable` Typ zu einem `Writable` Typ verschoben werden können (Konzept)
IndirectlyMovableStorable	spezifiziert, dass Werte von einem `Readable` Typ zu einem `Writable` Typ verschoben werden können und dass die Verschiebung über ein Zwischenobjekt erfolgen kann (Konzept)
IndirectlyCopyable	spezifiziert, dass Werte von einem `Readable` Typ zu einem `Writable` Typ kopiert werden können (Konzept)
IndirectlyCopyableStorable	spezifiziert, dass Werte von einem `Readable` Typ zu einem `Writable` Typ kopiert werden können und dass die Kopie über ein Zwischenobjekt erfolgen kann (Konzept)
IndirectlySwappable	spezifiziert, dass die von zwei `Readable` Typen referenzierten Werte ausgetauscht werden können (Konzept)
IndirectlyComparable	spezifiziert, dass die von zwei `Readable` Typen referenzierten Werte verglichen werden können (Konzept)
Permutable	spezifiziert die allgemeinen Anforderungen von Algorithmen, die Elemente an Ort und Stelle neu anordnen (Konzept)
Mergeable	spezifiziert die Anforderungen von Algorithmen, die sortierte Sequenzen durch Kopieren von Elementen in eine Ausgabesequenz zusammenführen (Konzept)
Sortable	spezifiziert die allgemeinen Anforderungen von Algorithmen, die Sequenzen in geordnete Sequenzen umordnen (Konzept)

Konzept-Hilfsmittel

indirect_result_of	Berechnet das Ergebnis des Aufrufs eines aufrufbaren Objekts auf das Ergebnis der Dereferenzierung einiger `Readable` Typen (Klassentemplate)
projected	Hilfstemplate zur Spezifikation der Constraints für Algorithmen, die Projektionen akzeptieren (Klassentemplate)

Iterator-Primitive

Iterator-Hilfsfunktionen

Definiert im Namespace `std::experimental::ranges`
iter_move	wandelt das Ergebnis der Dereferenzierung eines Objekts in seinen zugehörigen Rvalue-Referenztyp um (Anpassungspunktobjekt)
iter_swap	tauscht die von zwei dereferenzierbaren Objekten referenzierten Werte (Anpassungspunktobjekt)

Iterator-Eigenschaften

Definiert im Namespace `std::experimental::ranges`
difference_type	ermittelt den Differenztyp eines `WeaklyIncrementable` Typs (Klassentemplate)
value_type	ermittelt den Werttyp eines `Readable` Typs (Klassentemplate)
iterator_category	ermittelt die Iteratorkategorie eines Input-Iterator-Typs (Klassentemplate)
iterator_traits	Kompatibilitäts-Traits-Klasse, die die assoziierten Typen eines Iterators sammelt (Alias-Template)
reference_t rvalue_reference_t iter_common_reference_t	ermittelt die assoziierten Referenztypen eines dereferenzierbaren Objekts (Alias-Template)

Iterator-Kategorie-Tags

Definiert im Namespace `std::experimental::ranges`
input_iterator_tag output_iterator_tag forward_iterator_tag bidirectional_iterator_tag random_access_iterator_tag	Leere Klassentypen, die zur Kennzeichnung 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 (Klassen-Template-Spezialisierung)

Iterator-Operationen

Definiert im Namespace `std::experimental::ranges`
advance	bewegt einen Iterator um eine gegebene Distanz (Funktions-Template)
distance	gibt die Distanz zwischen einem Iterator und einem Sentinel zurück, oder zwischen dem Anfang und dem Ende eines Bereichs (Funktions-Template)
next	erhöht einen Iterator (Funktions-Template)
prev	verringert einen Iterator (Funktions-Template)

Iterator-Adapter

Definiert im Namespace `std::experimental::ranges`
reverse_iterator	Iterator-Adapter für die Traversierung in umgekehrter Reihenfolge (Klassentemplate)
back_insert_iterator	Iterator-Adapter für das Einfügen am Ende eines Containers (Klassentemplate)
front_insert_iterator	Iterator-Adapter für das Einfügen am Anfang eines Containers (Klassentemplate)
insert_iterator	Iterator-Adapter für das Einfügen in einen Container (Klassentemplate)
move_iterator	Iterator-Adapter, der zu einer Rvalue-Referenz dereferenziert (Klassentemplate)
move_sentinel	Sentinel-Adapter zur Verwendung mit `move_iterator` (Klassentemplate)
common_iterator	Passt ein Iterator-Sentinel-Paar an einen gemeinsamen Iteratortyp für die Verwendung mit Legacy-Algorithmen an (Klassentemplate)
counted_iterator	Iterator-Adapter, der den Abstand von seiner Startposition verfolgt (Klassentemplate)
default_sentinel	Leerer Sentinel-Typ für die Verwendung mit Iteratortypen, die die Grenze ihres Bereichs kennen (Klasse)
dangling	Wrapper für einen möglicherweise hängenden Iterator (Klassentemplate)
safe_iterator_t	Alias-Template, das den Iteratortyp eines Rvalue-Bereichs mit `dangling` umschließt (Alias-Template)
unreachable	Sentinel-Typ, der mit jedem Iterator verwendet wird, um einen unendlichen Bereich zu bezeichnen (Klasse)

Stream-Iteratoren

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

Zusammenfassung

namespace std { namespace experimental { namespace ranges { inline namespace v1 {
template <class T> concept bool /* dereferenceable */ // exposition only
  = requires(T& t) { {*t} -> auto&&; };
namespace {
  constexpr /* nicht spezifiziert */ iter_move = /* nicht spezifiziert */;
  constexpr /* nicht spezifiziert */ iter_swap = /* nicht spezifiziert */;
}
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 </* dereferenzierbar */ T> using reference_t
  = decltype(*declval<T&>());
template </* dereferenceable */ T>
    requires /* siehe Definition */ using rvalue_reference_t
  = decltype(ranges::iter_move(declval<T&>()));
template <class In>
concept bool Readable = /* siehe Definition */;
template <class Out, class T>
concept bool Writable = /* siehe Definition */;
template <class I>
concept bool WeaklyIncrementable = /* siehe Definition */;
template <class I>
concept bool Incrementable = /* siehe Definition */;
template <class I>
concept bool Iterator = /* siehe Definition */;
template <class S, class I>
concept bool Sentinel = /* siehe Definition */;
template <class S, class I>
  constexpr bool disable_sized_sentinel = false;
template <class S, class I>
concept bool SizedSentinel = /* siehe Definition */;
template <class I>
concept bool InputIterator = /* siehe Definition */;
template <class I>
concept bool OutputIterator = /* siehe Definition */;
template <class I>
concept bool ForwardIterator = /* siehe Definition */;
template <class I>
concept bool BidirectionalIterator = /* siehe Definition */;
template <class I>
concept bool RandomAccessIterator = /* siehe Definition */;
template <class F, class I>
concept bool IndirectUnaryInvocable = /* siehe Definition */;
template <class F, class I>
concept bool IndirectRegularUnaryInvocable = /* siehe Definition */;
template <class F, class I>
concept bool IndirectUnaryPredicate = /* siehe Definition */;
template <class F, class I1, class I2 = I1>
concept bool IndirectRelation = /* siehe Definition */;
template <class F, class I1, class I2 = I1>
concept bool IndirectStrictWeakOrder = /* siehe Definition */;
template <class> struct indirect_result_of;
template <class F, class... Ist>
  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 = /* siehe Definition */;
template <class In, class Out>
concept bool IndirectlyMovableStorable = /* siehe Definition */;
template <class In, class Out>
concept bool IndirectlyCopyable = /* siehe Definition */;
template <class In, class Out>
concept bool IndirectlyCopyableStorable = /* siehe Definition */;
template <class I1, class I2 = I1>
concept bool IndirectlySwappable = /* siehe Definition */;
template <class I1, class I2, class R = equal_to<>, class P1 = identity,
    class P2 = identity>
concept bool IndirectlyComparable = /* siehe Definition */;
template <class I>
concept bool Permutable = /* siehe Definition */;
template <class I1, class I2, class Out,
    class R = less<>, class P1 = identity, class P2 = identity>
concept bool Mergeable = /* siehe Definition */;
template <class I, class R = less<>, class P = identity>
concept bool Sortable = /* siehe Definition */;
template <class Iterator> using iterator_traits = /* siehe 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 /* nicht spezifiziert */ advance = /* nicht spezifiziert */;
  constexpr /* nicht spezifiziert */ distance = /* nicht spezifiziert */;
  constexpr /* nicht spezifiziert */ next = /* nicht spezifiziert */;
  constexpr /* nicht spezifiziert */ prev = /* nicht spezifiziert */;
}
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;
}

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

cppreference.net

Namespaces

Variants