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>

Cet en-tête fait partie de la bibliothèque ranges .

Table des matières

Concepts liés aux itérateurs

Défini dans l'espace de noms


           std::experimental::ranges

Concepts des itérateurs

Readable	spécifie qu'un type est lisible en appliquant l'opérateur `*` (concept)
Writable	spécifie qu'une valeur peut être écrite dans l'objet référencé d'un itérateur (concept)
WeaklyIncrementable	spécifie qu'un type `Semiregular` peut être incrémenté avec les opérateurs de pré-incrémentation et post-incrémentation (concept)
Incrementable	spécifie que l'opération d'incrémentation sur un type `WeaklyIncrementable` préserve l'égalité et que le type est `EqualityComparable` (concept)
Iterator	spécifie que les objets d'un type peuvent être incrémentés et déréférencés (concept)
Sentinel	spécifie que les objets d'un type sont des sentinelles pour un type `Iterator` (concept)
SizedSentinel	spécifie que l'opérateur `-` peut être appliqué à un itérateur et une sentinelle pour calculer leur différence en temps constant (concept)
InputIterator	spécifie qu'un type est un itérateur d'entrée, c'est-à-dire que ses valeurs référencées peuvent être lues et qu'il peut être pré-incrémenté et post-incrémenté (concept)
OutputIterator	spécifie qu'un type est un itérateur de sortie pour un type de valeur donné, c'est-à-dire que des valeurs de ce type peuvent y être écrites et qu'il peut être pré-incrémenté et post-incrémenté (concept)
ForwardIterator	spécifie qu'un `InputIterator` est un itérateur avant, supportant la comparaison d'égalité et le multi-passage (concept)
BidirectionalIterator	spécifie qu'un `ForwardIterator` est un itérateur bidirectionnel, supportant le déplacement vers l'arrière (concept)
RandomAccessIterator	spécifie qu'un `BidirectionalIterator` est un itérateur à accès aléatoire, supportant l'avancement en temps constant et l'indexation (concept)

Concepts d'appel indirect

IndirectUnaryInvocable IndirectRegularUnaryInvocable	spécifie qu'un type appelable peut être invoqué avec le résultat du déréférencement d'un `Readable` type (concept)
IndirectUnaryPredicate	spécifie qu'un objet appelable, lorsqu'il est invoqué avec le résultat du déréférencement d'un `Readable` type, satisfait `Predicate` (concept)
IndirectRelation	spécifie qu'un objet appelable, lorsqu'il est invoqué avec le résultat du déréférencement de certains `Readable` types, satisfait `Relation` (concept)
IndirectStrictWeakOrder	spécifie qu'un objet appelable, lorsqu'il est invoqué avec le résultat du déréférencement de certains `Readable` types, satisfait `StrictWeakOrder` (concept)

Exigences communes des algorithmes

IndirectlyMovable	spécifie que les valeurs peuvent être déplacées d'un `Readable` type vers un `Writable` type (concept)
IndirectlyMovableStorable	spécifie que les valeurs peuvent être déplacées d'un `Readable` type vers un `Writable` type et que le déplacement peut être effectué via un objet intermédiaire (concept)
IndirectlyCopyable	spécifie que les valeurs peuvent être copiées d'un `Readable` type vers un `Writable` type (concept)
IndirectlyCopyableStorable	spécifie que les valeurs peuvent être copiées d'un `Readable` type vers un `Writable` type et que la copie peut être effectuée via un objet intermédiaire (concept)
IndirectlySwappable	spécifie que les valeurs référencées par deux `Readable` types peuvent être échangées (concept)
IndirectlyComparable	spécifie que les valeurs référencées par deux `Readable` types peuvent être comparées (concept)
Permutable	spécifie les exigences communes des algorithmes qui réorganisent les éléments en place (concept)
Mergeable	spécifie les exigences des algorithmes qui fusionnent des séquences triées en une séquence de sortie en copiant les éléments (concept)
Sortable	spécifie les exigences communes des algorithmes qui réorganisent les séquences en séquences ordonnées (concept)

Utilitaires de concepts

indirect_result_of	calcule le résultat de l'invocation d'un objet appelable sur le résultat du déréférencement d'un ensemble de `Readable` types (modèle de classe)
projected	modèle utilitaire pour spécifier les contraintes sur les algorithmes qui acceptent des projections (modèle de classe)

Primitives d'itérateur

Utilitaires d'itérateur

Défini dans l'espace de noms `std::experimental::ranges`
iter_move	convertit le résultat du déréférencement d'un objet en son type de référence rvalue associé (objet point de personnalisation)
iter_swap	échange les valeurs référencées par deux objets déréférençables (objet point de personnalisation)

Caractéristiques des itérateurs

Défini dans l'espace de noms `std::experimental::ranges`
difference_type	obtient le type de différence d'un type `WeaklyIncrementable` (modèle de classe)
value_type	obtient le type de valeur d'un type `Readable` (modèle de classe)
iterator_category	obtient la catégorie d'itérateur d'un type d'itérateur d'entrée (modèle de classe)
iterator_traits	classe de traits de compatibilité qui collecte les types associés d'un itérateur (modèle d'alias)
reference_t rvalue_reference_t iter_common_reference_t	obtient les types de référence associés d'un objet déréférençable (modèle d'alias)

Étiquettes de catégorie d'itérateur

Défini dans l'espace de noms `std::experimental::ranges`
input_iterator_tag output_iterator_tag forward_iterator_tag bidirectional_iterator_tag random_access_iterator_tag	types de classes vides utilisés pour indiquer les catégories d'itérateurs (classe)

std::iterator_traits spécialisations

Défini dans l'espace de noms `std`
std::iterator_traits <InputIterator> std::iterator_traits <OutputIterator>	spécialise std::iterator_traits pour les itérateurs du TS ranges (spécialisation de modèle de classe)

Opérations sur les itérateurs

Défini dans l'espace de noms `std::experimental::ranges`
advance	avance un itérateur d'une distance donnée (modèle de fonction)
distance	retourne la distance entre un itérateur et un sentinelle, ou entre le début et la fin d'une plage (modèle de fonction)
next	incrémente un itérateur (modèle de fonction)
prev	décrémente un itérateur (modèle de fonction)

Adaptateurs d'itérateurs

Défini dans l'espace de noms `std::experimental::ranges`
reverse_iterator	adaptateur d'itérateur pour le parcours en ordre inverse (modèle de classe)
back_insert_iterator	adaptateur d'itérateur pour l'insertion à la fin d'un conteneur (modèle de classe)
front_insert_iterator	adaptateur d'itérateur pour l'insertion au début d'un conteneur (modèle de classe)
insert_iterator	adaptateur d'itérateur pour l'insertion dans un conteneur (modèle de classe)
move_iterator	adaptateur d'itérateur qui déréférence vers une référence rvalue (modèle de classe)
move_sentinel	adaptateur de sentinelle à utiliser avec `move_iterator` (modèle de classe)
common_iterator	adapte une paire itérateur-sentinelle en un type d'itérateur commun pour utilisation avec les algorithmes hérités (modèle de classe)
counted_iterator	adaptateur d'itérateur qui garde trace de sa distance depuis sa position de départ (modèle de classe)
default_sentinel	type de sentinelle vide pour utilisation avec les types d'itérateurs qui connaissent la limite de leur plage (classe)
dangling	enveloppe pour un itérateur potentiellement suspendu (modèle de classe)
safe_iterator_t	modèle d'alias qui enveloppe le type d'itérateur d'une plage rvalue avec `dangling` (modèle d'alias)
unreachable	type de sentinelle utilisé avec n'importe quel itérateur pour désigner une plage infinie (classe)

Itérateurs de flux

Défini dans l'espace de noms `std::experimental::ranges`
istream_iterator	itérateur d'entrée qui lit depuis std::basic_istream (modèle de classe)
ostream_iterator	itérateur de sortie qui écrit vers std::basic_ostream (modèle de classe)
istreambuf_iterator	itérateur d'entrée qui lit depuis std::basic_streambuf (modèle de classe)
ostreambuf_iterator	itérateur de sortie qui écrit vers std::basic_streambuf (modèle de classe)

Synopsis

namespace std { namespace experimental { namespace ranges { inline namespace v1 {
template <class T> concept bool /* déréférençable */ // exposition uniquement
  = requires(T& t) { {*t} -> auto&&; };
namespace {
  constexpr /* non spécifié */ iter_move = /* non spécifié */;
  constexpr /* non spécifié */ iter_swap = /* non spécifié */;
}
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 </* déréférençable */ T> using reference_t
  = decltype(*declval<T&>());
template </* déréférençable */ T>
    requires /* voir définition */ using rvalue_reference_t
  = decltype(ranges::iter_move(declval<T&>()));
template <class In>
concept bool Readable = /* voir définition */;
template <class Out, class T>
concept bool Writable = /* voir définition */;
template <class I>
concept bool WeaklyIncrementable = /* voir définition */;
template <class I>
concept bool Incrementable = /* voir définition */;
template <class I>
concept bool Iterator = /* voir définition */;
template <class S, class I>
concept bool Sentinel = /* voir définition */;
template <class S, class I>
  constexpr bool disable_sized_sentinel = false;
template <class S, class I>
concept bool SizedSentinel = /* voir définition */;
template <class I>
concept bool InputIterator = /* voir définition */;
template <class I>
concept bool OutputIterator = /* voir définition */;
template <class I>
concept bool ForwardIterator = /* voir définition */;
template <class I>
concept bool BidirectionalIterator = /* voir définition */;
template <class I>
concept bool RandomAccessIterator = /* voir définition */;
template <class F, class I>
concept bool IndirectUnaryInvocable = /* voir définition */;
template <class F, class I>
concept bool IndirectRegularUnaryInvocable = /* voir définition */;
template <class F, class I>
concept bool IndirectUnaryPredicate = /* voir définition */;
template <class F, class I1, class I2 = I1>
concept bool IndirectRelation = /* voir définition */;
template <class F, class I1, class I2 = I1>
concept bool IndirectStrictWeakOrder = /* voir définition */;
template <class> struct indirect_result_of;
template <class F, class... Est>
  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 = /* voir définition */;
template <class In, class Out>
concept bool IndirectlyMovableStorable = /* voir définition */;
template <class In, class Out>
concept bool IndirectlyCopyable = /* voir définition */;
template <class In, class Out>
concept bool IndirectlyCopyableStorable = /* voir définition */;
template <class I1, class I2 = I1>
concept bool IndirectlySwappable = /* voir définition */;
template <class I1, class I2, class R = equal_to<>, class P1 = identity,
    class P2 = identity>
concept bool IndirectlyComparable = /* voir définition */;
template <class I>
concept bool Permutable = /* voir définition */;
template <class I1, class I2, class Out,
    class R = less<>, class P1 = identity, class P2 = identity>
concept bool Mergeable = /* voir définition */;
template <class I, class R = less<>, class P = identity>
concept bool Sortable = /* voir définition */;
template <class Iterator> using iterator_traits = /* voir définition */;
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 /* non spécifié */ advance = /* non spécifié */;
  constexpr /* non spécifié */ distance = /* non spécifié */;
  constexpr /* non spécifié */ next = /* non spécifié */;
  constexpr /* non spécifié */ prev = /* non spécifié */;
}
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::Sentinelle<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