Standard library header <iterator>

From cppreference.net

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

Cet en-tête est un en-tête freestanding partiel. Tout le contenu de cet en-tête est freestanding à l'exception des itérateurs de flux.

(depuis C++23)

Table des matières

Concepts

Concepts des itérateurs

indirectly_readable

(C++20)

spécifie qu'un type est indirectement lisible en appliquant l'opérateur

(concept)

indirectly_writable

(C++20)

spécifie qu'une valeur peut être écrite dans l'objet référencé par un itérateur
(concept)

weakly_incrementable

(C++20)

spécifie qu'un type


           semiregular

peut être incrémenté avec les opérateurs de pré-incrémentation et post-incrémentation
(concept)

incrementable

(C++20)

spécifie que l'opération d'incrémentation sur un type


           weakly_incrementable

préserve l'égalité et que le type est


           equality_comparable

(concept)

input_or_output_iterator

(C++20)

spécifie que les objets d'un type peuvent être incrémentés et déréférencés
(concept)

sentinel_for

(C++20)

spécifie qu'un type est un sentinelle pour un type


           input_or_output_iterator

(concept)

sized_sentinel_for

(C++20)

spécifie que l'opérateur - peut être appliqué à un itérateur et un sentinelle pour calculer leur différence en temps constant
(concept)

input_iterator

(C++20)

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)

output_iterator

(C++20)

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)

forward_iterator

(C++20)

spécifie qu'un


           input_iterator

est un itérateur avant, supportant la comparaison d'égalité et le multi-passage
(concept)

bidirectional_iterator

(C++20)

spécifie qu'un


           forward_iterator

est un itérateur bidirectionnel, prenant en charge le déplacement vers l'arrière
(concept)

random_access_iterator

(C++20)

spécifie qu'un


           bidirectional_iterator

est un itérateur à accès aléatoire, prenant en charge l'avancement en temps constant et l'indexation
(concept)

contiguous_iterator

(C++20)

spécifie qu'un


           random_access_iterator

est un itérateur contigu, se référant à des éléments contigus en mémoire
(concept)

Concepts d'appel indirect

indirectly_unary_invocable indirectly_regular_unary_invocable

(C++20) (C++20)

spécifie qu'un type appelable peut être invoqué avec le résultat du déréférencement d'un


           indirectly_readable

type
(concept)

indirect_unary_predicate

(C++20)

spécifie qu'un type appelable, lorsqu'il est invoqué avec le résultat du déréférencement d'un


           indirectly_readable

type, satisfait


           predicate

(concept)

indirect_binary_predicate

(C++20)

spécifie qu'un type appelable, lorsqu'il est invoqué avec le résultat du déréférencement de deux


           indirectly_readable

types, satisfait


           predicate

(concept)

indirect_equivalence_relation

(C++20)

spécifie qu'un type appelable, lorsqu'il est invoqué avec le résultat du déréférencement de deux


           indirectly_readable

types, satisfait


           equivalence_relation

(concept)

indirect_strict_weak_order

(C++20)

spécifie qu'un type appelable, lorsqu'il est invoqué avec le résultat du déréférencement de deux


           indirectly_readable

types, satisfait


           strict_weak_order

(concept)

Exigences communes des algorithmes

indirectly_movable

(C++20)

spécifie que les valeurs peuvent être déplacées d'un


           indirectly_readable

vers un


           indirectly_writable

type
(concept)

indirectly_movable_storable

(C++20)

spécifie que les valeurs peuvent être déplacées d'un


           indirectly_readable

vers un


           indirectly_writable

et que le déplacement peut être effectué via un objet intermédiaire
(concept)

indirectly_copyable

(C++20)

spécifie que les valeurs peuvent être copiées d'un


           indirectly_readable

type vers un


           indirectly_writable

type
(concept)

indirectly_copyable_storable

(C++20)

spécifie que les valeurs peuvent être copiées d'un


           indirectly_readable

vers un


           indirectly_writable

et que la copie peut être effectuée via un objet intermédiaire
(concept)

indirectly_swappable

(C++20)

spécifie que les valeurs référencées par deux


           indirectly_readable

types peuvent être échangées
(concept)

indirectly_comparable

(C++20)

spécifie que les valeurs référencées par deux


           indirectly_readable

types peuvent être comparées
(concept)

permutable

(C++20)

spécifie les exigences communes des algorithmes qui réorganisent les éléments sur place
(concept)

mergeable

(C++20)

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

(C++20)

spécifie les exigences communes des algorithmes qui réorganisent les séquences en séquences ordonnées
(concept)

Classes

Utilitaires d'algorithmes

indirect_result_t

(C++20)

calcule le résultat de l'invocation d'un objet appelable sur le résultat de la déréférencement d'un ensemble de


           indirectly_readable

types
(modèle d'alias)

projected

(C++20)

modèle d'aide pour spécifier les contraintes sur les algorithmes qui acceptent des projections
(modèle d'alias)

projected_value_t

(C++26)

calcule le type de valeur d'un


           indirectly_readable

par projection
(alias de modèle)

Types associés

incrementable_traits

(C++20)

calcule le type de différence d'un


           weakly_incrementable

type
(modèle de classe)

indirectly_readable_traits

(C++20)

calcule le type de valeur d'un


           indirectly_readable

type
(modèle de classe)

iter_value_t iter_reference_t iter_const_reference_t iter_difference_t iter_rvalue_reference_t iter_common_reference_t

(C++20) (C++20) (C++23) (C++20) (C++20) (C++20)

calcule les types associés d'un itérateur
(modèle d'alias)

Primitives

iterator_traits

fournit une interface uniforme pour les propriétés d'un itérateur
(modèle de classe)

input_iterator_tag output_iterator_tag forward_iterator_tag bidirectional_iterator_tag random_access_iterator_tag contiguous_iterator_tag

(C++20)

types de classes vides utilisés pour indiquer les catégories d'itérateurs
(classe)

iterator

(obsolète en C++17)

classe de base pour faciliter la définition des types requis pour les itérateurs simples
(modèle de classe)

Adaptateurs

reverse_iterator

adaptateur d'itérateur pour le parcours en ordre inverse
(modèle de classe)

move_iterator

(C++11)

adaptateur d'itérateur qui se déréférence en une rvalue
(modèle de classe)

move_sentinel

(C++20)

adaptateur de sentinelle pour std::move_iterator
(modèle de classe)

basic_const_iterator

(C++23)

adaptateur d'itérateur qui convertit un itérateur en itérateur constant
(modèle de classe)

const_iterator

(C++23)

calcule un type d'itérateur constant pour un type donné
(alias de template)

const_sentinel

(C++23)

calcule un type sentinelle à utiliser avec les itérateurs constants
(alias template)

common_iterator

(C++20)

adapte un type d'itérateur et son sentinelle en un type d'itérateur commun
(modèle de classe)

default_sentinel_t

(C++20)

sentinelle par défaut pour utilisation avec les itérateurs qui connaissent la limite de leur plage
(classe)

counted_iterator

(C++20)

adaptateur d'itérateur qui suit la distance jusqu'à la fin de la plage
(modèle de classe)

unreachable_sentinel_t

(C++20)

sentinelle qui compare toujours inégale à tout type


           weakly_incrementable

(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)

Itérateurs de Flux

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 dans 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)

Objets de point de personnalisation

Défini dans l'espace de noms


           std::ranges

iter_move

(C++20)

convertit le résultat du déréférencement d'un objet en sa référence rvalue associée
(objet de point de personnalisation)

iter_swap

(C++20)

échange les valeurs référencées par deux objets déréférençables
(objet de point de personnalisation)

Constantes

unreachable_sentinel

(C++20)

un objet de type


          unreachable_sentinel_t

qui compare toujours inégal à tout type


           weakly_incrementable

(constante)

default_sentinel

(C++20)

un objet de type


          default_sentinel_t

utilisé avec les itérateurs qui connaissent la limite de leur plage
(constante)

Fonctions

Adaptateurs

make_reverse_iterator

(C++14)

crée un std::reverse_iterator dont le type est déduit de l'argument
(modèle de fonction)

make_move_iterator

(C++11)

crée un std::move_iterator dont le type est déduit de l'argument
(modèle de fonction)

make_const_iterator

(C++23)

crée un std::const_iterator dont le type est déduit de l'argument
(modèle de fonction)

make_const_sentinel

(C++23)

crée un std::const_sentinel dont le type est déduit de l'argument
(modèle de fonction)

front_inserter

crée un std::front_insert_iterator dont le type est déduit de l'argument
(modèle de fonction)

back_inserter

crée un std::back_insert_iterator dont le type est déduit de l'argument
(modèle de fonction)

inserter

crée un std::insert_iterator dont le type est déduit de l'argument
(modèle de fonction)

Opérateurs non membres

operator== operator!= operator< operator<= operator> operator>= operator<=>

(C++11) (C++11) (supprimé en C++20) (C++11) (C++11) (C++11) (C++11) (C++20)

compare les itérateurs sous-jacents
(modèle de fonction)

operator+

(C++11)

avance l'itérateur
(modèle de fonction)

operator-

(C++11)

calcule la distance entre deux adaptateurs d'itérateur
(modèle de fonction)

operator== operator!= operator< operator<= operator> operator>= operator<=>

(C++20)

compare les itérateurs sous-jacents
(modèle de fonction)

operator+

avance l'itérateur
(modèle de fonction)

operator-

calcule la distance entre deux adaptateurs d'itérateur
(modèle de fonction)

operator== operator<=>

(C++20)

compare les distances jusqu'à la fin
(modèle de fonction)

operator+

(C++20)

avance l'itérateur
(modèle de fonction)

operator-

(C++20)

calcule la distance entre deux adaptateurs d'itérateur
(modèle de fonction)

operator== operator!=

(supprimé en C++20)

compare deux


          istream_iterator

s
(modèle de fonction)

operator== operator!=

(supprimé en C++20)

compare deux


          istreambuf_iterator

s
(modèle de fonction)

Opérations

advance

avance un itérateur d'une distance donnée
(modèle de fonction)

distance

retourne la distance entre deux itérateurs
(modèle de fonction)

(C++11)

incrémente un itérateur
(modèle de fonction)

(C++11)

décrémente un itérateur
(modèle de fonction)

ranges::advance

(C++20)

avance un itérateur d'une distance donnée ou jusqu'à une limite spécifiée
(objet fonction algorithme)

ranges::distance

(C++20)

retourne la distance entre un itérateur et un sentinelle, ou entre le début et la fin d'un intervalle
(objet fonction algorithme)

ranges::next

(C++20)

incrémente un itérateur d'une distance donnée ou jusqu'à une limite
(objet fonction algorithme)

ranges::prev

(C++20)

décrémente un itérateur d'une distance donnée ou jusqu'à une limite
(objet fonction algorithme)

Accès aux plages

begin cbegin

(C++11) (C++14)

retourne un itérateur vers le début d'un conteneur ou d'un tableau
(fonction template)

end cend

(C++11) (C++14)

retourne un itérateur vers la fin d'un conteneur ou d'un tableau
(modèle de fonction)

rbegin crbegin

(C++14)

retourne un itérateur inverse vers le début d'un conteneur ou d'un tableau
(modèle de fonction)

rend crend

(C++14)

retourne un itérateur de fin inverse pour un conteneur ou un tableau
(modèle de fonction)

size ssize

(C++17) (C++20)

renvoie la taille d'un conteneur ou d'un tableau
(modèle de fonction)

empty

(C++17)

vérifie si le conteneur est vide
(modèle de fonction)

data

(C++17)

obtient le pointeur vers le tableau sous-jacent
(fonction template)

Synopsis

#include <compare>
#include <concepts>
namespace std {
  template<class T> using /* avec-référence */ = T&;  // exposition uniquement
  template<class T> concept /* peut-être référencé */       // exposition uniquement
    = requires { typename /* avec-référence */<T>; };
  template<class T> concept /* déréférençable */     // exposition uniquement
    = requires(T& t) {
      { *t } -> /* peut-être référencé */;  // non requis d'être préservateur d'égalité
    };
  // types associés
  // traits incrémentables
  template<class> struct incrementable_traits;
  template<class T>
    using iter_difference_t = /* voir description */;
  // traits indirectement lisibles
  template<class> struct indirectly_readable_traits;
  template<class T>
    using iter_value_t = /* voir description */;
  // traits d'itérateur
  template<class I> struct iterator_traits;
  template<class T> requires is_object_v<T> struct iterator_traits<T*>;
  template</* déréférençable */ T>
    using iter_reference_t = decltype(*declval<T&>());
  namespace ranges {
    // points de personnalisation d'objets
    inline namespace /* non spécifié */ {
      // ranges::iter_move
      inline constexpr /* non spécifié */ iter_move = /* non spécifié */;
      // ranges::iter_swap
      inline constexpr /* non spécifié */ iter_swap = /* non spécifié */;
    }
  }
  template</* déréférençable */ T>
    requires requires(T& t) {
      { ranges::iter_move(t) } -> /* peut-être référencé */;
    }
  using iter_rvalue_reference_t
    = decltype(ranges::iter_move(declval<T&>()));
  // concepts d'itérateur
  // concept indirectly_readable
  template<class In>
    concept indirectly_readable = /* voir description */;
  template<indirectly_readable T>
    using iter_common_reference_t =
      common_reference_t<iter_reference_t<T>, iter_value_t<T>&>;
  // concept indirectly_writable
  template<class Out, class T>
    concept indirectly_writable = /* voir description */;
  // concept faiblement_incrémentable
  template<class I>
    concept weakly_incrementable = /* voir description */;
  // concept incrémentable
  template<class I>
    concept incrementable = /* voir description */;
  // concept input_or_output_iterator
  template<class I>
    concept input_or_output_iterator = /* voir description */;
  // concept sentinel_for
  template<class S, class I>
    concept sentinel_for = /* voir description */;
  // concept sized_sentinel_for
  template<class S, class I>
    inline constexpr bool disable_sized_sentinel_for = false;
  template<class S, class I>
    concept sized_sentinel_for = /* voir description */;
  // concept input_iterator
  template<class I>
    concept input_iterator = /* voir description */;
  // concept output_iterator
  template<class I, class T>
    concept output_iterator = /* voir description */;
  // concept forward_iterator
  template<class I>
    concept forward_iterator = /* voir description */;
  // concept itérateur bidirectionnel
  template<class I>
    concept bidirectional_iterator = /* voir description */;
  // concept random_access_iterator
  template<class I>
    concept random_access_iterator = /* voir description */;
  // concept itérateur contigu
  template<class I>
    concept contiguous_iterator = /* voir description */;
  // exigences d'appel indirect
  // appelables indirects
  template<class F, class I>
    concept indirectly_unary_invocable = /* voir description */;
  template<class F, class I>
    concept indirectly_regular_unary_invocable = /* voir description */;
  template<class F, class I>
    concept indirect_unary_predicate = /* voir description */;
  template<class F, class I1, class I2>
    concept indirect_binary_predicate = /* voir description */;
  template<class F, class I1, class I2 = I1>
    concept indirect_equivalence_relation = /* voir description */;
  template<class F, class I1, class I2 = I1>
    concept indirect_strict_weak_order = /* voir description */;
  template<class F, class... Est>
    requires (indirectly_readable<Is> && ...) && invocable<F, iter_reference_t<Is>...>
      using indirect_result_t = invoke_result_t<F, iter_reference_t<Is>...>;
  // projeté
  template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
    using projected = /* voir description */;
  template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
    using projected_value_t = remove_cvref_t<invoke_result_t<Proj&, iter_value_t<I>&>>;
  // exigences communes d'algorithmes
  // concept indirectly_movable
  template<class In, class Out>
    concept indirectly_movable = /* voir description */;
  template<class In, class Out>
    concept indirectly_movable_storable = /* voir description */;
  // concept indirectement copiable
  template<class In, class Out>
    concept indirectly_copyable = /* voir description */;
  template<class In, class Out>
    concept indirectly_copyable_storable = /* voir description */;
  // concept indirectly_swappable
  template<class I1, class I2 = I1>
    concept indirectly_swappable = /* voir description */;
  // concept indirectly_comparable
  template<class I1, class I2, class R, class P1 = identity, class P2 = identity>
    concept indirectly_comparable = /* voir description */;
  // concept permutable
  template<class I>
    concept permutable = /* voir description */;
  // concept fusionnable
  template<class I1, class I2, class Out,
      class R = ranges::less, class P1 = identity, class P2 = identity>
    concept mergeable = /* voir description */;
  // concept triable
  template<class I, class R = ranges::less, class P = identity>
    concept sortable = /* voir description */;
  // primitives
  // étiquettes d'itérateur
  struct input_iterator_tag { };
  struct output_iterator_tag { };
  struct forward_iterator_tag: public input_iterator_tag { };
  struct bidirectional_iterator_tag: public forward_iterator_tag { };
  struct random_access_iterator_tag: public bidirectional_iterator_tag { };
  struct contiguous_iterator_tag: public random_access_iterator_tag { };
  // opérations d'itérateur
  template<class InputIt, class Distance>
    constexpr void advance(InputIt& i, Distance n);
  template<class InputIt>
    constexpr typename iterator_traits<InputIt>::difference_type
      distance(InputIt first, InputIt last);
  template<class InputIt>
    constexpr InputIt
      next(InputIt x, typename iterator_traits<InputIt>::difference_type n = 1);
  template<class BidirIt>
    constexpr BidirIt
      prev(BidirIt x, typename iterator_traits<BidirIt>::difference_type n = 1);
  // opérations d'itérateur de plage
  namespace ranges {
    // ranges::advance
    template<input_or_output_iterator I>
      constexpr void advance(I& i, iter_difference_t<I> n);
    template<input_or_output_iterator I, sentinel_for<I> S>
      constexpr void advance(I& i, S bound);
    template<input_or_output_iterator I, sentinel_for<I> S>
      constexpr iter_difference_t<I> advance(I& i, iter_difference_t<I> n, S bound);
    // ranges::distance
    template<class I, sentinel_for<I> S>
      requires (!sized_sentinel_for<S, I>)
      constexpr iter_difference_t<I> distance(I first, S last);
    template<class I, sized_sentinel_for<decay_t<I>> S>
      constexpr iter_difference_t<decay_t<I>> distance(I&& first, S last);
    template<range R>
      constexpr range_difference_t<R> distance(R&& r);
    // ranges::next
    template<input_or_output_iterator I>
      constexpr I next(I x);
    template<input_or_output_iterator I>
      constexpr I next(I x, iter_difference_t<I> n);
    template<input_or_output_iterator I, sentinel_for<I> S>
      constexpr I next(I x, S bound);
    template<input_or_output_iterator I, sentinel_for<I> S>
      constexpr I next(I x, iter_difference_t<I> n, S bound);
    // ranges::prev
    template<bidirectional_iterator I>
      constexpr I prev(I x);
    template<bidirectional_iterator I>
      constexpr I prev(I x, iter_difference_t<I> n);
    template<bidirectional_iterator I>
      constexpr I prev(I x, iter_difference_t<I> n, I bound);
  }
  // itérateurs et sentinelles prédéfinis
  // itérateurs inverses
  template<class It> class reverse_iterator;
  template<class It1, class It2>
    constexpr bool operator==(const reverse_iterator<It1>& x,
                              const reverse_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator!=(const reverse_iterator<It1>& x,
                              const reverse_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator<(const reverse_iterator<It1>& x,
                             const reverse_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator>(const reverse_iterator<It1>& x,
                             const reverse_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator<=(const reverse_iterator<It1>& x,
                              const reverse_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator>=(const reverse_iterator<It1>& x,
                              const reverse_iterator<It2>& y);
  template<class It1, three_way_comparable_with<It1> It2>
    constexpr compare_three_way_result_t<It1, It2>
      operator<=>(const reverse_iterator<It1>& x, const reverse_iterator<It2>& y);
  template<class It1, class It2>
    constexpr auto operator-(const reverse_iterator<It1>& x,
                             const reverse_iterator<It2>& y)
      -> decltype(y.base() - x.base());
  template<class It>
    constexpr reverse_iterator<It> operator+(iter_difference_t<It> n,
                                             const reverse_iterator<It>& x);
  template<class It>
    constexpr reverse_iterator<It> make_reverse_iterator(It i);
  template<class It1, class It2>
      requires (!sized_sentinel_for<It1, It2>)
    inline constexpr bool disable_sized_sentinel_for<reverse_iterator<It1>,
                                                     reverse_iterator<It2>> = true;
  // itérateurs d'insertion
  template<class Container> class back_insert_iterator;
  template<class Container>
    constexpr back_insert_iterator<Container> back_inserter(Container& x);
  template<class Container> class front_insert_iterator;
  template<class Container>
    constexpr front_insert_iterator<Container> front_inserter(Container& x);
  template<class Container> class insert_iterator;
  template<class Container>
    constexpr insert_iterator<Container>
      inserter(Container& x, ranges::iterator_t<Container> i);
  // itérateurs et sentinelles de déplacement
  template<class It> class move_iterator;
  template<class It1, class It2>
    constexpr bool operator==(const move_iterator<It1>& x, const move_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator<(const move_iterator<It1>& x, const move_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator>(const move_iterator<It1>& x, const move_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator<=(const move_iterator<It1>& x, const move_iterator<It2>& y);
  template<class It1, class It2>
    constexpr bool operator>=(const move_iterator<It1>& x, const move_iterator<It2>& y);
  template<class It1, three_way_comparable_with<It1> It2>
    constexpr compare_three_way_result_t<It1, It2>
      operator<=>(const move_iterator<It1>& x, const move_iterator<It2>& y);
  template<class It1, class It2>
    constexpr auto operator-(const move_iterator<It1>& x, const move_iterator<It2>& y)
      -> decltype(x.base() - y.base());
  template<class It>
    constexpr move_iterator<It>
      operator+(iter_difference_t<It> n, const move_iterator<It>& x);
  template<class It>
    constexpr move_iterator<It> make_move_iterator(It i);
  template<semiregular S> class move_sentinel;
  // itérateurs courants
  template<input_or_output_iterator I, sentinel_for<I> S>
    requires (!same_as<I, S> && copyable<I>)
      class common_iterator;
  template<class I, class S>
    struct incrementable_traits<common_iterator<I, S>>;
  template<input_iterator I, class S>
    struct iterator_traits<common_iterator<I, S>>;
  // sentinelle par défaut
  struct default_sentinel_t;
  inline constexpr default_sentinel_t default_sentinel{};
  // itérateurs comptés
  template<input_or_output_iterator I> class counted_iterator;
  template<input_iterator I>
    requires /* voir description */
    struct iterator_traits<counted_iterator<I>>;
  // sentinelle inaccessible
  struct unreachable_sentinel_t;
  inline constexpr unreachable_sentinel_t unreachable_sentinel{};
  // itérateurs de flux
  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 = 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 = char_traits<CharT>>
    class ostreambuf_iterator;
  // accès aux plages
  template<class C> constexpr auto begin(C& c) -> decltype(c.begin());
  template<class C> constexpr auto begin(const C& c) -> decltype(c.begin());
  template<class C> constexpr auto end(C& c) -> decltype(c.end());
  template<class C> constexpr auto end(const C& c) -> decltype(c.end());
  template<class T, size_t N> constexpr T* begin(T (&a)[N]) noexcept;
  template<class T, size_t N> constexpr T* end(T (&a)[N]) noexcept;
  template<class C> constexpr auto cbegin(const C& c) noexcept(noexcept(std::begin(c)))
    -> decltype(std::begin(c));
  template<class C> constexpr auto cend(const C& c) noexcept(noexcept(std::end(c)))
    -> decltype(std::end(c));
  template<class C> constexpr auto rbegin(C& c) -> decltype(c.rbegin());
  template<class C> constexpr auto rbegin(const C& c) -> decltype(c.rbegin());
  template<class C> constexpr auto rend(C& c) -> decltype(c.rend());
  template<class C> constexpr auto rend(const C& c) -> decltype(c.rend());
  template<class T, size_t N> constexpr reverse_iterator<T*> rbegin(T (&a)[N]);
  template<class T, size_t N> constexpr reverse_iterator<T*> rend(T (&a)[N]);
  template<class E> constexpr reverse_iterator<const E*> rbegin(initializer_list<E> il);
  template<class E> constexpr reverse_iterator<const E*> rend(initializer_list<E> il);
  template<class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c));
  template<class C> constexpr auto crend(const C& c) -> decltype(std::rend(c));
  template<class C> constexpr auto size(const C& c) -> decltype(c.size());
  template<class T, size_t N> constexpr size_t size(const T (&a)[N]) noexcept;
  template<class C> constexpr auto ssize(const C& c)
    -> common_type_t<ptrdiff_t, make_signed_t<decltype(c.size())>>;
  template<class T, ptrdiff_t N> constexpr ptrdiff_t ssize(const T (&a)[N]) noexcept;
  template<class C> constexpr auto empty(const C& c) -> decltype(c.empty());
  template<class T, size_t N> constexpr bool empty(const T (&a)[N]) noexcept;
  template<class E> constexpr bool empty(initializer_list<E> il) noexcept;
  template<class C> constexpr auto data(C& c) -> decltype(c.data());
  template<class C> constexpr auto data(const C& c) -> decltype(c.data());
  template<class T, size_t N> constexpr T* data(T (&a)[N]) noexcept;
  template<class E> constexpr const E* data(initializer_list<E> il) noexcept;
}

Concept `indirectly_readable`

namespace std {
  template<class In>
    concept /*indirectlyReadableImpl*/ = // exposition uniquement
      requires(const In in) {
        typename iter_value_t<In>;
        typename iter_reference_t<In>;
        typename iter_rvalue_reference_t<In>;
        { *in } -> same_as<iter_reference_t<In>>
        { iter_move(in) } -> same_as<iter_rvalue_reference_t<In>>
      } &&
      common_reference_with<iter_reference_t<In>&&, iter_value_t<In>&> &&
      common_reference_with<iter_reference_t<In>&&, iter_rvalue_reference_t<In>&&> &&
      common_reference_with<iter_rvalue_reference_t<In>&&, const iter_value_t<In>&>;
  template<class In>
    concept indirectly_readable =
      /*indirectlyReadableImpl*/<remove_cvref_t<In>>
}

Concept `indirectly_writable`

namespace std {
  template<class Out, class T>
    concept indirectly_writable =
      requires(Out&& o, T&& t) {
        *o = std::forward<T>(t); // non requis pour préserver l'égalité
        *std::forward<Out>(o) = std::forward<T>(t);
        // non requis pour préserver l'égalité
        const_cast<const iter_reference_t<Out>&&>(*o) =
        std::forward<T>(t); // non requis pour préserver l'égalité
        const_cast<const iter_reference_t<Out>&&>(*std::forward<Out>(o)) =
        std::forward<T>(t); // non requis pour préserver l'égalité
      };
}

Concept `weakly_incrementable`

namespace std {
  template<class T>
    inline constexpr bool /*is_integer_like*/ = /* voir description */; // exposition seulement
  template<class T>
    inline constexpr bool /*is_signed_integer_like*/ =  // exposition seulement
      /* voir description */;
  template<class I>
    concept weakly_incrementable =
      default_initializable<I> && movable<I> &&
      requires(I i) {
        typename iter_difference_t<I>;
        requires /*is_signed_integer_like*/<iter_difference_t<I>>;
        { ++i } -> same_as<I&>;   // non requis pour être égalité-préservant
        i++;                      // non requis pour être égalité-préservant
      };
}

Concept `incrementable`

namespace std {
  template<class I>
    concept incrementable =
      regular<I> &&
      weakly_incrementable<I> &&
      requires(I i) {
        { i++ } -> same_as<I>;
      };
}

Concept `input_or_output_iterator`

namespace std {
  template<class I>
    concept input_or_output_iterator =
      requires(I i) {
        { *i } -> can-reference;
      } &&
      weakly_incrementable<I>;
}

Concept `sentinel_for`

namespace std {
  template<class S, class I>
    concept sentinel_for =
      semiregular<S> &&
      input_or_output_iterator<I> &&
      /*WeaklyEqualityComparableWith*/<S, I>;
}

Concept `sized_sentinel_for`

namespace std {
  template<class S, class I>
    concept sized_sentinel_for =
      sentinel_for<S, I> &&
      !disable_sized_sentinel<remove_cv_t<S>, remove_cv_t<I>> &&
      requires(const I& i, const S& s) {
        { s - i } -> same_as<iter_difference_t<I>>;
        { i - s } -> same_as<iter_difference_t<I>>;
      };
}

Concept `input_iterator`

namespace std {
  template<class I>
    concept input_iterator =
      input_or_output_iterator<I> &&
      indirectly_readable<I> &&
      requires { typename /* ITER_CONCEPT */(I); } &&
      derived_from</* ITER_CONCEPT */(I), input_iterator_tag>;
}

Concept `output_iterator`

namespace std {
  template<class I, class T>
    concept output_iterator =
      input_or_output_iterator<I> &&
      indirectly_writable<I, T> &&
      requires(I i, T&& t) {
        *i++ = std::forward<T>(t); // non requis pour préserver l'égalité
      };
}

Concept `forward_iterator`

namespace std {
  template<class I>
    concept forward_iterator =
      input_iterator<I> &&
      derived_from</* ITER_CONCEPT */(I), forward_iterator_tag> &&
      incrementable<I> &&
      sentinel_for<I, I>;
}

Concept `bidirectional_iterator`

namespace std {
  template<class I>
    concept bidirectional_iterator =
      forward_iterator<I> &&
      derived_from</* ITER_CONCEPT */(I), bidirectional_iterator_tag> &&
      requires(I i) {
        { --i } -> same_as<I&>;
        { i-- } -> same_as<I>;
      };
}

Concept `random_access_iterator`

namespace std {
  template<class I>
    concept random_access_iterator =
      bidirectional_iterator<I> &&
      derived_from</* ITER_CONCEPT */(I), random_access_iterator_tag> &&
      totally_ordered<I> &&
      sized_sentinel_for<I, I> &&
      requires(I i, const I j, const iter_difference_t<I> n) {
        { i += n } -> same_as<I&>;
        { j +  n } -> same_as<I>;
        { n +  j } -> same_as<I>;
        { i -= n } -> same_as<I&>;
        { j -  n } -> same_as<I>;
        {  j[n]  } -> same_as<iter_reference_t<I>>;
      };
}

*Note: Le code C++ fourni ne contient aucun texte traduisible en dehors des balises HTML. Tous les éléments visibles sont soit des mots-clés C++, des identifiants, des opérateurs ou des commentaires dans le code, qui ne doivent pas être traduits selon les instructions.*

Concept `contiguous_iterator`

namespace std {
  template<class I>
    concept contiguous_iterator =
      random_access_iterator<I> &&
      derived_from</* ITER_CONCEPT */(I), contiguous_iterator_tag> &&
      is_lvalue_reference_v<iter_reference_t<I>> &&
      same_as<iter_value_t<I>, remove_cvref_t<iter_reference_t<I>>> &&
      requires(const I& i) {
        { to_address(i) } -> same_as<add_pointer_t<iter_reference_t<I>>>;
      };
}

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `

` et contient des termes spécifiques au C++. Seule cette note explicative est en français.

Concept `indirectly_unary_invocable`

namespace std {
  template<class F, class I>
    concept indirectly_unary_invocable =
      indirectly_readable<I> &&
      copy_constructible<F> &&
      invocable<F&, iter_value_t<I>&> &&
      invocable<F&, iter_reference_t<I>> &&
      common_reference_with<
        invoke_result_t<F&, iter_value_t<I>&>,
        invoke_result_t<F&, iter_reference_t<I>>>;
}

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `

` et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant (s'il y en avait) aurait été traduit en français.

Concept `indirectly_regular_unary_invocable`

namespace std {
  template<class F, class I>
    concept indirectly_regular_unary_invocable =
      indirectly_readable<I> &&
      copy_constructible<F> &&
      regular_invocable<F&, iter_value_t<I>&> &&
      regular_invocable<F&, iter_reference_t<I>> &&
      common_reference_with<
        invoke_result_t<F&, iter_value_t<I>&>,
        invoke_result_t<F&, iter_reference_t<I>>>;
}

*Note: Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `

` et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant aurait été traduit s'il y en avait eu.*

Concept `indirect_unary_predicate`

namespace std {
  template<class F, class I>
    concept indirect_unary_predicate =
      indirectly_readable<I> &&
      copy_constructible<F> &&
      predicate<F&, iter_value_t<I>&> &&
      predicate<F&, iter_reference_t<I>>;
}

Concept `indirect_binary_predicate`

namespace std {
  template<class F, class I1, class I2 = I1>
    concept indirect_binary_predicate =
      indirectly_readable<I1> && indirectly_readable<I2> &&
      copy_constructible<F> &&
      predicate<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
      predicate<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
      predicate<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
      predicate<F&, iter_reference_t<I1>, iter_reference_t<I2>>;
}

**Note:** Le code C++ n'a pas été traduit car il se trouve dans des balises `

` et contient des termes spécifiques au C++ qui doivent être préservés selon les instructions. Seul le texte environnant aurait été traduit s'il y en avait eu.

Concept `indirect_equivalence_relation`

namespace std {
  template<class F, class I1, class I2 = I1>
    concept relation_d_équivalence_indirecte =
      indirectement_lisible<I1> && indirectement_lisible<I2> &&
      copiable<F> &&
      relation_d_équivalence<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
      relation_d_équivalence<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
      relation_d_équivalence<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
      relation_d_équivalence<F&, iter_reference_t<I1>, iter_reference_t<I2>>;
}

Concept `indirect_strict_weak_order`

namespace std {
  template<class F, class I1, class I2 = I1>
    concept indirect_strict_weak_order =
      indirectly_readable<I1> && indirectly_readable<I2> &&
      copy_constructible<F> &&
      strict_weak_order<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
      strict_weak_order<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
      strict_weak_order<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
      strict_weak_order<F&, iter_reference_t<I1>, iter_reference_t<I2>>;
}

Concept `indirectly_movable`

namespace std {
  template<class In, class Out>
    concept indirectly_movable =
      indirectly_readable<In> &&
      indirectly_writable<Out, iter_rvalue_reference_t<In>>;
}

**Note:** Le code C++ n'a pas été traduit car il se trouve dans des balises `

` et contient des termes spécifiques au C++ qui doivent être préservés. Le texte environnant ne contenait aucun contenu à traduire en dehors du code.

Concept `indirectly_movable_storable`

namespace std {
  template<class In, class Out>
    concept indirectly_movable_storable =
      indirectly_movable<In, Out> &&
      indirectly_writable<Out, iter_value_t<In>> &&
      movable<iter_value_t<In>> &&
      constructible_from<iter_value_t<In>, iter_rvalue_reference_t<In>> &&
      assignable_from<iter_value_t<In>&, iter_rvalue_reference_t<In>>;
}

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `

` et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant (comme cette note) a été traduit en français.

Concept `indirectly_copyable`

namespace std {
  template<class In, class Out>
    concept indirectly_copyable =
      indirectly_readable<In> &&
      indirectly_writable<Out, iter_reference_t<In>>;
}

Concept `indirectly_copyable_storable`

namespace std {
  template<class In, class Out>
    concept indirectly_copyable_storable =
      indirectly_copyable<In, Out> &&
      indirectly_writable<Out, iter_value_t<In>&> &&
      indirectly_writable<Out, const iter_value_t<In>&> &&
      indirectly_writable<Out, iter_value_t<In>&&> &&
      indirectly_writable<Out, const iter_value_t<In>&&> &&
      copyable<iter_value_t<In>> &&
      constructible_from<iter_value_t<In>, iter_reference_t<In>> &&
      assignable_from<iter_value_t<In>&, iter_reference_t<In>>;
}

Concept `indirectly_swappable`

namespace std {
  template<class I1, class I2 = I1>
    concept indirectly_swappable =
      indirectly_readable<I1> && indirectly_readable<I2> &&
      requires(const I1 i1, const I2 i2) {
        ranges::iter_swap(i1, i1);
        ranges::iter_swap(i2, i2);
        ranges::iter_swap(i1, i2);
        ranges::iter_swap(i2, i1);
      };
}

Concept `indirectly_comparable`

namespace std {
  template<class I1, class I2, class R, class P1 = identity, class P2 = identity>
    concept indirectly_comparable =
      indirect_predicate<R, projected<I1, P1>, projected<I2, P2>>;
}

Concept `permutable`

namespace std {
  template<class I>
    concept permutable =
      forward_iterator<I> &&
      indirectly_movable_storable<I, I> &&
      indirectly_swappable<I, I>;
}

Concept `mergeable`

namespace std {
  template<class I1, class I2, class Out, class R = ranges::less,
           class P1 = identity, class P2 = identity>
    concept mergeable =
      input_iterator<I1> &&
      input_iterator<I2> &&
      weakly_incrementable<Out> &&
      indirectly_copyable<I1, Out> &&
      indirectly_copyable<I2, Out> &&
      indirect_strict_weak_order<R, projected<I1, P1>, projected<I2, P2>>;
}

Concept `sortable`

namespace std {
  template<class I, class R = ranges::less, class P = identity>
    concept sortable =
      permutable<I> &&
      indirect_strict_weak_order<R, projected<I, P>>;
}

Modèle de classe std::incrementable_traits

namespace std {
  template<class> struct incrementable_traits { };
  template<class T>
    requires is_object_v<T>
  struct incrementable_traits<T*> {
    using difference_type = ptrdiff_t;
  };
  template<class I>
  struct incrementable_traits<const I>
    : incrementable_traits<I> { };
  template<class T>
    requires requires { typename T::difference_type; }
  struct incrementable_traits<T> {
    using difference_type = typename T::difference_type;
  };
  template<class T>
    requires (!requires { typename T::difference_type; } &&
              requires(const T& a, const T& b) { { a - b } -> integral; })
  struct incrementable_traits<T> {
    using difference_type = make_signed_t<decltype(declval<T>() - declval<T>())>;
  };
  template<class T>
    using iter_difference_t = /* voir description */;
}

Modèle de classe std::indirectly_readable_traits

namespace std {
  template<class> struct /*cond_value_type*/ { };   // exposition uniquement
  template<class T>
    requires is_object_v<T>
  struct /*cond_value_type*/ {
    using value_type = remove_cv_t<T>;
  };
  template<class> struct indirectly_readable_traits { };
  template<class T>
  struct indirectly_readable_traits<T*>
    : /*cond_value_type*/<T> { };
  template<class I>
    requires is_array_v<I>
  struct indirectly_readable_traits<I> {
    using value_type = remove_cv_t<remove_extent_t<I>>;
  };
  template<class I>
  struct indirectly_readable_traits<const I>
    : indirectly_readable_traits<I> { };
  template<class T>
    requires requires { typename T::value_type; }
  struct indirectly_readable_traits<T>
    : /*cond_value_type*/<typename T::value_type> { };
  template<class T>
    requires requires { typename T::element_type; }
  struct indirectly_readable_traits<T>
    : /*cond_value_type*/<typename T::element_type> { };
}

Modèle de classe std::projected

namespace std {
  template<class I, class Proj>
  struct /*projected-impl*/ {                        // exposition uniquement
    struct /*type*/ {                                // exposition uniquement
      using value_type = remove_cvref_t<indirect_result_t<Proj&, I>>;
      using difference_type = iter_difference_t<I>;  // présent uniquement si I
                                                     // modélise weakly_incrementable
      indirect_result_t<Proj&, I> operator*() const; // non défini
    };
  };
  template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
  using projected = /*projected-impl*/<I, Proj>::/*type*/;
}

Modèle de classe std::iterator_traits

namespace std {
  template<class I>
  struct iterator_traits {
    using iterator_category = /* voir description */;
    using value_type        = /* voir description */;
    using difference_type   = /* voir description */;
    using pointer           = /* voir description */;
    using reference         = /* voir description */;
  };
  template<class T>
    requires is_object_v<T>
  struct iterator_traits<T*> {
    using iterator_concept  = contiguous_iterator_tag;
    using iterator_category = random_access_iterator_tag;
    using value_type        = remove_cv_t<T>;
    using difference_type   = ptrdiff_t;
    using pointer           = T*;
    using reference         = T&;
  };
}

Étiquettes d'itérateur

namespace std {
  struct input_iterator_tag { };
  struct output_iterator_tag { };
  struct forward_iterator_tag: public input_iterator_tag { };
  struct bidirectional_iterator_tag: public forward_iterator_tag { };
  struct random_access_iterator_tag: public bidirectional_iterator_tag { };
  struct contiguous_iterator_tag: public random_access_iterator_tag { };
}

Modèle de classe std::reverse_iterator

namespace std {
  template<class Iter>
  class reverse_iterator {
  public:
    using iterator_type     = Iter;
    using iterator_concept  = /* voir description */;
    using iterator_category = /* voir description */;
    using value_type        = iter_value_t<Iter>;
    using difference_type   = iter_difference_t<Iter>;
    using pointer           = typename iterator_traits<Iter>::pointer;
    using reference         = iter_reference_t<Iter>;
    constexpr reverse_iterator();
    constexpr explicit reverse_iterator(Iter x);
    template<class U> constexpr reverse_iterator(const reverse_iterator<U>& u);
    template<class U> constexpr reverse_iterator& operator=(const reverse_iterator<U>& u);
    constexpr Iter base() const;
    constexpr reference operator*() const;
    constexpr pointer   operator->() const requires /* voir description */;
    constexpr reverse_iterator& operator++();
    constexpr reverse_iterator  operator++(int);
    constexpr reverse_iterator& operator--();
    constexpr reverse_iterator  operator--(int);
    constexpr reverse_iterator  operator+ (difference_type n) const;
    constexpr reverse_iterator& operator+=(difference_type n);
    constexpr reverse_iterator  operator- (difference_type n) const;
    constexpr reverse_iterator& operator-=(difference_type n);
    constexpr /* non spécifié */ operator[](difference_type n) const;
    friend constexpr iter_rvalue_reference_t<Iter>
      iter_move(const reverse_iterator& i) noexcept(/* voir description */);
    template<indirectly_swappable<Iter> Iter2>
      friend constexpr void
        iter_swap(const reverse_iterator& x,
                  const reverse_iterator<Iter2>& y) noexcept(/* voir description */);
  protected:
    Iter current;
  };
}

Modèle de classe std::back_insert_iterator

namespace std {
  template<class Container>
  class back_insert_iterator {
  protected:
    Container* container = nullptr;
  public:
    using iterator_category = output_iterator_tag;
    using value_type        = void;
    using difference_type   = ptrdiff_t;
    using pointer           = void;
    using reference         = void;
    using container_type    = Container;
    constexpr back_insert_iterator() noexcept = default;
    constexpr explicit back_insert_iterator(Container& x);
    constexpr back_insert_iterator& operator=(const typename Container::value_type& value);
    constexpr back_insert_iterator& operator=(typename Container::value_type&& value);
    constexpr back_insert_iterator& operator*();
    constexpr back_insert_iterator& operator++();
    constexpr back_insert_iterator  operator++(int);
  };
}

*Note: Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `

` et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant aurait été traduit s'il y en avait eu.*

Modèle de classe std::front_insert_iterator

namespace std {
  template<class Container>
  class front_insert_iterator {
  protected:
    Container* container = nullptr;
  public:
    using iterator_category = output_iterator_tag;
    using value_type        = void;
    using difference_type   = ptrdiff_t;
    using pointer           = void;
    using reference         = void;
    using container_type    = Container;
    constexpr front_insert_iterator(Container& x) noexcept = default;
    constexpr explicit front_insert_iterator(Container& x);
    constexpr front_insert_iterator&
      operator=(const typename Container::value_type& value);
    constexpr front_insert_iterator& operator=(typename Container::value_type&& value);
    constexpr front_insert_iterator& operator*();
    constexpr front_insert_iterator& operator++();
    constexpr front_insert_iterator  operator++(int);
  };
}

Modèle de classe std::insert_iterator

namespace std {
  template<class Container>
  class insert_iterator {
  protected:
    Container* container = nullptr;
    ranges::iterator_t<Container> iter = ranges::iterator_t<Container>();
  public:
    using iterator_category = output_iterator_tag;
    using value_type        = void;
    using difference_type   = ptrdiff_t;
    using pointer           = void;
    using reference         = void;
    using container_type    = Container;
    insert_iterator() = default;
    constexpr insert_iterator(Container& x, ranges::iterator_t<Container> i);
    constexpr insert_iterator& operator=(const typename Container::value_type& value);
    constexpr insert_iterator& operator=(typename Container::value_type&& value);
    constexpr insert_iterator& operator*();
    constexpr insert_iterator& operator++();
    constexpr insert_iterator& operator++(int);
  };
}

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `

` et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant aurait été traduit s'il y en avait eu.

Modèle de classe std::move_iterator

namespace std {
  template<class Iter>
  class move_iterator {
  public:
    using iterator_type     = Iter;
    using iterator_concept  = /* voir description */;
    using iterator_category = /* voir description */;
    using value_type        = iter_value_t<Iter>;
    using difference_type   = iter_difference_t<Iter>;
    using pointer           = Iter;
    using reference         = iter_rvalue_reference_t<Iter>;
    constexpr move_iterator();
    constexpr explicit move_iterator(Iter i);
    template<class U> constexpr move_iterator(const move_iterator<U>& u);
    template<class U> constexpr move_iterator& operator=(const move_iterator<U>& u);
    constexpr iterator_type base() const &;
    constexpr iterator_type base() &&;
    constexpr reference operator*() const;
    constexpr pointer operator->() const;
    constexpr move_iterator& operator++();
    constexpr auto operator++(int);
    constexpr move_iterator& operator--();
    constexpr move_iterator operator--(int);
    constexpr move_iterator operator+(difference_type n) const;
    constexpr move_iterator& operator+=(difference_type n);
    constexpr move_iterator operator-(difference_type n) const;
    constexpr move_iterator& operator-=(difference_type n);
    constexpr reference operator[](difference_type n) const;
    template<sentinel_for<Iter> S>
      friend constexpr bool
        operator==(const move_iterator& x, const move_sentinel<S>& y);
    template<sized_sentinel_for<Iter> S>
      friend constexpr iter_difference_t<Iter>
        operator-(const move_sentinel<S>& x, const move_iterator& y);
    template<sized_sentinel_for<Iter> S>
      friend constexpr iter_difference_t<Iter>
        operator-(const move_iterator& x, const move_sentinel<S>& y);
    friend constexpr iter_rvalue_reference_t<Iter>
      iter_move(const move_iterator& i)
        noexcept(noexcept(ranges::iter_move(i.current)));
    template<indirectly_swappable<Iter> Iter2>
      friend constexpr void
        iter_swap(const move_iterator& x, const move_iterator<Iter2>& y)
          noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
  private:
    Iter current;     // exposition uniquement
  };
}

Modèle de classe std::move_sentinel

namespace std {
  template<semiregular S>
  class move_sentinel {
  public:
    constexpr move_sentinel();
    constexpr explicit move_sentinel(S s);
    template<class S2>
      requires convertible_to<const S2&, S>
        constexpr move_sentinel(const move_sentinel<S2>& s);
    template<class S2>
      requires assignable_from<S&, const S2&>
        constexpr move_sentinel& operator=(const move_sentinel<S2>& s);
    constexpr S base() const;
  private:
    S last;     // exposition uniquement
  };
}

Modèle de classe std::common_iterator

namespace std {
  template<input_or_output_iterator I, sentinel_for<I> S>
    requires (!same_as<I, S> && copyable<I>)
  class common_iterator {
  public:
    constexpr common_iterator() = default;
    constexpr common_iterator(I i);
    constexpr common_iterator(S s);
    template<class I2, class S2>
      requires convertible_to<const I2&, I> && convertible_to<const S2&, S>
        constexpr common_iterator(const common_iterator<I2, S2>& x);
    template<class I2, class S2>
      requires convertible_to<const I2&, I> && convertible_to<const S2&, S> &&
               assignable_from<I&, const I2&> && assignable_from<S&, const S2&>
        common_iterator& operator=(const common_iterator<I2, S2>& x);
    decltype(auto) operator*();
    decltype(auto) operator*() const
      requires dereferenceable<const I>;
    decltype(auto) operator->() const
      requires /* voir description */;
    common_iterator& operator++();
    decltype(auto) operator++(int);
    template<class I2, sentinel_for<I> S2>
      requires sentinel_for<S, I2>
    friend bool operator==(
      const common_iterator& x, const common_iterator<I2, S2>& y);
    template<class I2, sentinel_for<I> S2>
      requires sentinel_for<S, I2> && equality_comparable_with<I, I2>
    friend bool operator==(
      const common_iterator& x, const common_iterator<I2, S2>& y);
    template<sized_sentinel_for<I> I2, sized_sentinel_for<I> S2>
      requires sized_sentinel_for<S, I2>
    friend iter_difference_t<I2> operator-(
      const common_iterator& x, const common_iterator<I2, S2>& y);
    friend constexpr decltype(auto) iter_move(const common_iterator& i)
      noexcept(noexcept(ranges::iter_move(declval<const I&>())))
        requires input_iterator<I>;
    template<indirectly_swappable<I> I2, class S2>
      friend void iter_swap(const common_iterator& x, const common_iterator<I2, S2>& y)
        noexcept(noexcept(ranges::iter_swap(declval<const I&>(), declval<const I2&>())));
  private:
    variant<I, S> v_;   // exposition uniquement
  };
  template<class I, class S>
  struct incrementable_traits<common_iterator<I, S>> {
    using difference_type = iter_difference_t<I>;
  };
  template<input_iterator I, class S>
  struct iterator_traits<common_iterator<I, S>> {
    using iterator_concept = /* voir description */;
    using iterator_category = /* voir description */;
    using value_type = iter_value_t<I>;
    using difference_type = iter_difference_t<I>;
    using pointer = /* voir description */;
    using reference = iter_reference_t<I>;
  };
}

Classe std::default_sentinel_t

namespace std {
  struct default_sentinel_t { };
}

Modèle de classe std::counted_iterator

namespace std {
  template<input_or_output_iterator I>
  class counted_iterator {
  public:
    using iterator_type = I;
    constexpr counted_iterator() = default;
    constexpr counted_iterator(I x, iter_difference_t<I> n);
    template<class I2>
      requires convertible_to<const I2&, I>
        constexpr counted_iterator(const counted_iterator<I2>& x);
    template<class I2>
      requires assignable_from<I&, const I2&>
        constexpr counted_iterator& operator=(const counted_iterator<I2>& x);
    constexpr I base() const & requires copy_constructible<I>;
    constexpr I base() &&;
    constexpr iter_difference_t<I> count() const noexcept;
    constexpr decltype(auto) operator*();
    constexpr decltype(auto) operator*() const
      requires dereferenceable<const I>;
    constexpr auto operator->() const noexcept
      requires contiguous_iterator<I>;
    constexpr counted_iterator& operator++();
    decltype(auto) operator++(int);
    constexpr counted_iterator operator++(int)
      requires forward_iterator<I>;
    constexpr counted_iterator& operator--()
      requires bidirectional_iterator<I>;
    constexpr counted_iterator operator--(int)
      requires bidirectional_iterator<I>;
    constexpr counted_iterator operator+(iter_difference_t<I> n) const
      requires random_access_iterator<I>;
    friend constexpr counted_iterator operator+(
      iter_difference_t<I> n, const counted_iterator& x)
        requires random_access_iterator<I>;
    constexpr counted_iterator& operator+=(iter_difference_t<I> n)
      requires random_access_iterator<I>;
    constexpr counted_iterator operator-(iter_difference_t<I> n) const
      requires random_access_iterator<I>;
    template<common_with<I> I2>
      friend constexpr iter_difference_t<I2> operator-(
        const counted_iterator& x, const counted_iterator<I2>& y);
    friend constexpr iter_difference_t<I> operator-(
      const counted_iterator& x, default_sentinel_t);
    friend constexpr iter_difference_t<I> operator-(
      default_sentinel_t, const counted_iterator& y);
    constexpr counted_iterator& operator-=(iter_difference_t<I> n)
      requires random_access_iterator<I>;
    constexpr decltype(auto) operator[](iter_difference_t<I> n) const
      requires random_access_iterator<I>;
    template<common_with<I> I2>
      friend constexpr bool operator==(
        const counted_iterator& x, const counted_iterator<I2>& y);
    friend constexpr bool operator==(
      const counted_iterator& x, default_sentinel_t);
    template<common_with<I> I2>
      friend constexpr strong_ordering operator<=>(
        const counted_iterator& x, const counted_iterator<I2>& y);
    friend constexpr decltype(auto) iter_move(const counted_iterator& i)
      noexcept(noexcept(ranges::iter_move(i.current)))
        requires input_iterator<I>;
    template<indirectly_swappable<I> I2>
      friend constexpr void iter_swap(const counted_iterator& x,
                                      const counted_iterator<I2>& y)
        noexcept(noexcept(ranges::iter_swap(x.current, y.current)));
  private:
    I current = I();                    // exposition uniquement
    iter_difference_t<I> length = 0;    // exposition uniquement
  };
  template<input_iterator I>
  struct iterator_traits<counted_iterator<I>> : iterator_traits<I> {
    using pointer = void;
  };
}

Classe std::unreachable_sentinel_t

namespace std {
  struct unreachable_sentinel_t {
    template<weakly_incrementable I>
      friend constexpr bool operator==(unreachable_sentinel_t, const I&) noexcept
      { return false; }
  };
}

Modèle de classe std::istream_iterator

namespace std {
  template<class T, class CharT = char, class Traits = char_traits<CharT>,
           class Distance = ptrdiff_t>
  class istream_iterator {
  public:
    using iterator_category = input_iterator_tag;
    using value_type        = T;
    using difference_type   = Distance;
    using pointer           = const T*;
    using reference         = const T&;
    using char_type         = CharT;
    using traits_type       = Traits;
    using istream_type      = basic_istream<CharT, Traits>;
    constexpr istream_iterator();
    constexpr istream_iterator(default_sentinel_t);
    istream_iterator(istream_type& s);
    istream_iterator(const istream_iterator& x) = default;
    ~istream_iterator() = default;
    istream_iterator& operator=(const istream_iterator&) = default;
    const T& operator*() const;
    const T* operator->() const;
    istream_iterator& operator++();
    istream_iterator  operator++(int);
    friend bool operator==(const istream_iterator& i, default_sentinel_t);
  private:
    basic_istream<CharT, Traits>* in_stream; // exposition uniquement
    T value;                                 // exposition uniquement
  };
}

Modèle de classe std::ostream_iterator

namespace std {
  template<class T, class CharT = char, classTraits = char_traits<CharT>>
  class ostream_iterator {
  public:
    using iterator_category = output_iterator_tag;
    using value_type        = void;
    using difference_type   = ptrdiff_t;
    using pointer           = void;
    using reference         = void;
    using char_type         = CharT;
    using traits_type       = Traits;
    using ostream_type      = basic_ostream<CharT, Traits>;
    constexpr ostreambuf_iterator() noexcept = default;
    ostream_iterator(ostream_type& s);
    ostream_iterator(ostream_type& s, const CharT* delimiter);
    ostream_iterator(const ostream_iterator& x);
    ~ostream_iterator();
    ostream_iterator& operator=(const ostream_iterator&) = default;
    ostream_iterator& operator=(const T& value);
    ostream_iterator& operator*();
    ostream_iterator& operator++();
    ostream_iterator& operator++(int);
  private:
    basic_ostream<CharT, Traits>* out_stream = nullptr;          // exposition uniquement
    const CharT* delim = nullptr;                                // exposition uniquement
  };
}

Modèle de classe std::istreambuf_iterator

namespace std {
  template<class CharT, class Traits = char_traits<CharT>>
  class istreambuf_iterator {
  public:
    using iterator_category = input_iterator_tag;
    using value_type        = CharT;
    using difference_type   = typename Traits::off_type;
    using pointer           = /* non spécifié */;
    using reference         = CharT;
    using char_type         = CharT;
    using traits_type       = Traits;
    using int_type          = typename Traits::int_type;
    using streambuf_type    = basic_streambuf<CharT, Traits>;
    using istream_type      = basic_istream<CharT, Traits>;
    class proxy;                          // exposition uniquement
    constexpr istreambuf_iterator() noexcept;
    constexpr istreambuf_iterator(default_sentinel_t) noexcept;
    istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
    ~istreambuf_iterator() = default;
    istreambuf_iterator(istream_type& s) noexcept;
    istreambuf_iterator(streambuf_type* s) noexcept;
    istreambuf_iterator(const proxy& p) noexcept;
    istreambuf_iterator& operator=(const istreambuf_iterator&) noexcept = default;
    CharT operator*() const;
    istreambuf_iterator& operator++();
    proxy operator++(int);
    bool equal(const istreambuf_iterator& b) const;
    friend bool operator==(const istreambuf_iterator& i, default_sentinel_t s);
  private:
    streambuf_type* sbuf_;                // exposition uniquement
  };
  template<class CharT, class Traits>
  class istreambuf_iterator<CharT, Traits>::proxy { // exposition uniquement
    CharT keep_;
    basic_streambuf<CharT, Traits>* sbuf_;
    proxy(CharT c, basic_streambuf<CharT, Traits>* sbuf)
      : keep_(c), sbuf_(sbuf) { }
  public:
    CharT operator*() { return keep_; }
  };
}

Modèle de classe std::ostreambuf_iterator

namespace std {
  template<class CharT, class Traits = char_traits<CharT>>
  class ostreambuf_iterator {
  public:
    using iterator_category = output_iterator_tag;
    using value_type        = void;
    using difference_type   = ptrdiff_t;
    using pointer           = void;
    using reference         = void;
    using char_type         = CharT;
    using traits_type       = Traits;
    using streambuf_type    = basic_streambuf<CharT, Traits>;
    using ostream_type      = basic_ostream<CharT, Traits>;
    constexpr ostreambuf_iterator() noexcept = default;
    ostreambuf_iterator(ostream_type& s) noexcept;
    ostreambuf_iterator(streambuf_type* s) noexcept;
    ostreambuf_iterator& operator=(CharT c);
    ostreambuf_iterator& operator*();
    ostreambuf_iterator& operator++();
    ostreambuf_iterator& operator++(int);
    bool failed() const noexcept;
  private:
    streambuf_type* sbuf_ = nullptr;    // exposition uniquement
  };
}

Modèle de classe std::iterator

namespace std {
  template<class Category, class T, class Distance = ptrdiff_t,
           class Pointer = T*, class Reference = T&>
  struct iterator {
    typedef Category  iterator_category;
    typedef T         value_type;
    typedef Distance  difference_type;
    typedef Pointer   pointer;
    typedef Reference reference;
  };
}

**Note:** Le code C++ présenté dans les balises `

` n'a pas été traduit conformément aux instructions, car il s'agit de code source qui doit rester inchangé pour préserver sa fonctionnalité et sa syntaxe correcte. Les termes spécifiques au C++ (comme `namespace`, `template`, `struct`, `typedef`, etc.) sont conservés dans leur forme originale.

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR	S'applique à	Comportement publié	Comportement corrigé
LWG 349	C++98	le membre d'exposition uniquement `delim` de std::ostream_iterator avait le type const char *	corrigé en const CharT *

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

Standard library header <iterator>

Table des matières

Concepts

Concepts des itérateurs

Concepts d'appel indirect

Exigences communes des algorithmes

Classes

Utilitaires d'algorithmes

Types associés

Primitives

Adaptateurs

Itérateurs de Flux

Objets de point de personnalisation

Constantes

Fonctions

Adaptateurs

Opérateurs non membres

Opérations

Accès aux plages

Synopsis

Concept indirectly_readable

Concept indirectly_writable

Concept weakly_incrementable

Concept incrementable

Concept input_or_output_iterator

Concept sentinel_for

Concept sized_sentinel_for

Concept input_iterator

Concept output_iterator

Concept forward_iterator

Concept bidirectional_iterator

Concept random_access_iterator

Concept contiguous_iterator

Concept indirectly_unary_invocable

Concept indirectly_regular_unary_invocable

Concept indirect_unary_predicate

Concept indirect_binary_predicate

Concept indirect_equivalence_relation

Concept indirect_strict_weak_order

Concept indirectly_movable

Concept indirectly_movable_storable

Concept indirectly_copyable

Concept indirectly_copyable_storable

Concept indirectly_swappable

Concept indirectly_comparable

Concept permutable

Concept mergeable

Concept sortable

Modèle de classe std::incrementable_traits

Modèle de classe std::indirectly_readable_traits

Modèle de classe std::projected

Modèle de classe std::iterator_traits

Étiquettes d'itérateur

Modèle de classe std::reverse_iterator

Modèle de classe std::back_insert_iterator

Modèle de classe std::front_insert_iterator

Modèle de classe std::insert_iterator

Modèle de classe std::move_iterator

Modèle de classe std::move_sentinel

Modèle de classe std::common_iterator

Classe std::default_sentinel_t

Modèle de classe std::counted_iterator

Classe std::unreachable_sentinel_t

Modèle de classe std::istream_iterator

Modèle de classe std::ostream_iterator

Modèle de classe std::istreambuf_iterator

Modèle de classe std::ostreambuf_iterator

Modèle de classe std::iterator

Rapports de défauts

Concept `indirectly_readable`

Concept `indirectly_writable`

Concept `weakly_incrementable`

Concept `incrementable`

Concept `input_or_output_iterator`

Concept `sentinel_for`

Concept `sized_sentinel_for`

Concept `input_iterator`

Concept `output_iterator`

Concept `forward_iterator`

Concept `bidirectional_iterator`

Concept `random_access_iterator`

Concept `contiguous_iterator`

Concept `indirectly_unary_invocable`

Concept `indirectly_regular_unary_invocable`

Concept `indirect_unary_predicate`

Concept `indirect_binary_predicate`

Concept `indirect_equivalence_relation`

Concept `indirect_strict_weak_order`

Concept `indirectly_movable`

Concept `indirectly_movable_storable`

Concept `indirectly_copyable`

Concept `indirectly_copyable_storable`

Concept `indirectly_swappable`

Concept `indirectly_comparable`

Concept `permutable`

Concept `mergeable`

Concept `sortable`