Standard library header <iterator>

From cppreference.net

Este encabezado es parte de la biblioteca de iteradores .

Este encabezado es un encabezado independiente parcial. Todo dentro de este encabezado es independiente excepto los iteradores de flujo.

(since C++23)

Contenidos

Conceptos

Conceptos de iterador

indirectly_readable

(C++20)

especifica que un tipo es indirectamente legible aplicando el operador

(concept)

indirectly_writable

(C++20)

especifica que un valor puede ser escrito al objeto referenciado por un iterador
(concept)

weakly_incrementable

(C++20)

especifica que un tipo


           semiregular

puede ser incrementado con operadores de pre-incremento y post-incremento
(concepto)

incrementable

(C++20)

especifica que la operación de incremento en un tipo


           weakly_incrementable

es que preserva la igualdad y que el tipo es


           equality_comparable

(concepto)

input_or_output_iterator

(C++20)

especifica que los objetos de un tipo pueden ser incrementados y desreferenciados
(concept)

sentinel_for

(C++20)

especifica que un tipo es un centinela para un tipo


           input_or_output_iterator

(concepto)

sized_sentinel_for

(C++20)

especifica que el operador - puede aplicarse a un iterador y un centinela para calcular su diferencia en tiempo constante
(concepto)

input_iterator

(C++20)

especifica que un tipo es un iterador de entrada, es decir, sus valores referenciados pueden leerse y puede ser pre-incrementado y post-incrementado
(concept)

output_iterator

(C++20)

especifica que un tipo es un iterador de salida para un tipo de valor dado, es decir, se pueden escribir valores de ese tipo en él y puede ser pre- y post-incrementado
(concept)

forward_iterator

(C++20)

especifica que un


           input_iterator

es un iterador de avance, que admite comparación de igualdad y paso múltiple
(concepto)

bidirectional_iterator

(C++20)

especifica que un


           forward_iterator

es un iterador bidireccional, que admite movimiento hacia atrás
(concepto)

random_access_iterator

(C++20)

especifica que un


           bidirectional_iterator

es un iterador de acceso aleatorio, que admite avance en tiempo constante y subíndices
(concepto)

contiguous_iterator

(C++20)

especifica que un


           random_access_iterator

es un iterador contiguo, que hace referencia a elementos que son contiguos en memoria
(concepto)

Conceptos de invocación indirecta

indirectly_unary_invocable indirectly_regular_unary_invocable

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

especifica que un tipo invocable puede ser invocado con el resultado de desreferenciar un


           indirectly_readable

type
(concept)

indirect_unary_predicate

(C++20)

especifica que un tipo invocable, cuando se invoca con el resultado de desreferenciar un


           indirectly_readable

type, satisface


           predicate

(concepto)

indirect_binary_predicate

(C++20)

especifica que un tipo invocable, cuando se invoca con el resultado de desreferenciar dos


           indirectly_readable

tipos, satisface


           predicate

(concepto)

indirect_equivalence_relation

(C++20)

especifica que un tipo invocable, cuando se invoca con el resultado de desreferenciar dos


           indirectly_readable

tipos, satisface


           equivalence_relation

(concepto)

indirect_strict_weak_order

(C++20)

especifica que un tipo invocable, cuando se invoca con el resultado de desreferenciar dos


           indirectly_readable

tipos, satisface


           strict_weak_order

(concepto)

Requisitos comunes de algoritmos

indirectly_movable

(C++20)

especifica que los valores pueden ser movidos desde un


           indirectly_readable

tipo a un


           indirectly_writable

tipo
(concepto)

indirectly_movable_storable

(C++20)

especifica que los valores pueden ser movidos desde un


           indirectly_readable

tipo a un


           indirectly_writable

tipo y que la operación de movimiento puede realizarse a través de un objeto intermedio
(concepto)

indirectly_copyable

(C++20)

especifica que los valores pueden copiarse desde un


           indirectly_readable

tipo a un


           indirectly_writable

tipo
(concepto)

indirectly_copyable_storable

(C++20)

especifica que los valores pueden copiarse desde un


           indirectly_readable

tipo a un


           indirectly_writable

tipo y que la copia puede realizarse a través de un objeto intermedio
(concepto)

indirectly_swappable

(C++20)

especifica que los valores referenciados por dos


           indirectly_readable

tipos pueden intercambiarse
(concepto)

indirectly_comparable

(C++20)

especifica que los valores referenciados por dos


           indirectly_readable

tipos pueden ser comparados
(concepto)

permutable

(C++20)

especifica los requisitos comunes de los algoritmos que reordenan elementos in situ
(concept)

mergeable

(C++20)

especifica los requisitos de los algoritmos que fusionan secuencias ordenadas en una secuencia de salida copiando elementos
(concept)

sortable

(C++20)

especifica los requisitos comunes de los algoritmos que permutan secuencias en secuencias ordenadas
(concept)

Clases

Utilidades de algoritmos

indirect_result_t

(C++20)

calcula el resultado de invocar un objeto invocable sobre el resultado de desreferenciar algún conjunto de tipos


           indirectly_readable

(plantilla de alias)

projected

(C++20)

plantilla auxiliar para especificar las restricciones en algoritmos que aceptan proyecciones
(alias template)

projected_value_t

(C++26)

calcula el tipo de valor de un


           indirectly_readable

mediante proyección
(plantilla de alias)

Tipos asociados

incrementable_traits

(C++20)

calcula el tipo de diferencia de un


           weakly_incrementable

tipo
(plantilla de clase)

indirectly_readable_traits

(C++20)

calcula el tipo de valor de un


           indirectly_readable

type
(plantilla de clase)

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)

calcula los tipos asociados de un iterador
(plantilla de alias)

Primitivos

iterator_traits

proporciona una interfaz uniforme para las propiedades de un iterador
(plantilla de clase)

input_iterator_tag output_iterator_tag forward_iterator_tag bidirectional_iterator_tag random_access_iterator_tag contiguous_iterator_tag

(C++20)

tipos de clases vacías utilizados para indicar categorías de iteradores
(clase)

iterator

(deprecated in C++17)

clase base para facilitar la definición de tipos requeridos para iteradores simples
(class template)

Adaptadores

reverse_iterator

adaptador de iterador para recorrido en orden inverso
(plantilla de clase)

move_iterator

(C++11)

adaptador de iterador que se desreferencia a un valor r
(plantilla de clase)

move_sentinel

(C++20)

adaptador de centinela para std::move_iterator
(plantilla de clase)

basic_const_iterator

(C++23)

adaptador de iterador que convierte un iterador en un iterador constante
(plantilla de clase)

const_iterator

(C++23)

calcula un tipo de iterador constante para un tipo dado
(plantilla de alias)

const_sentinel

(C++23)

calcula un tipo de centinela para ser utilizado con iteradores constantes
(plantilla de alias)

common_iterator

(C++20)

adapta un tipo de iterador y su centinela en un tipo de iterador común
(plantilla de clase)

default_sentinel_t

(C++20)

centinela predeterminado para usar con iteradores que conocen el límite de su rango
(clase)

counted_iterator

(C++20)

adaptador de iterador que rastrea la distancia hasta el final del rango
(plantilla de clase)

unreachable_sentinel_t

(C++20)

centinela que siempre compara desigual con cualquier tipo


           weakly_incrementable

(clase)

back_insert_iterator

adaptador de iterador para inserción al final de un contenedor
(plantilla de clase)

front_insert_iterator

adaptador de iterador para inserción al frente de un contenedor
(plantilla de clase)

insert_iterator

adaptador de iterador para inserción en un contenedor
(plantilla de clase)

Iteradores de Flujo

istream_iterator

iterador de entrada que lee desde std::basic_istream
(plantilla de clase)

ostream_iterator

iterador de salida que escribe a std::basic_ostream
(plantilla de clase)

istreambuf_iterator

iterador de entrada que lee desde std::basic_streambuf
(plantilla de clase)

ostreambuf_iterator

iterador de salida que escribe en std::basic_streambuf
(plantilla de clase)

Objetos de punto de personalización

Definido en el espacio de nombres


           std::ranges

iter_move

(C++20)

convierte el resultado de desreferenciar un objeto a su tipo de referencia a valor asociado
(objeto de punto de personalización)

iter_swap

(C++20)

intercambia los valores referenciados por dos objetos desreferenciables
(objeto de punto de personalización)

Constantes

unreachable_sentinel

(C++20)

un objeto de tipo


          unreachable_sentinel_t

que siempre se compara desigual con cualquier tipo


           weakly_incrementable

(constante)

default_sentinel

(C++20)

un objeto de tipo


          default_sentinel_t

utilizado con iteradores que conocen el límite de su rango
(constante)

Funciones

Adaptadores

make_reverse_iterator

(C++14)

crea un std::reverse_iterator de tipo inferido a partir del argumento
(plantilla de función)

make_move_iterator

(C++11)

crea un std::move_iterator de tipo inferido a partir del argumento
(plantilla de función)

make_const_iterator

(C++23)

crea un std::const_iterator del tipo inferido del argumento
(plantilla de función)

make_const_sentinel

(C++23)

crea un std::const_sentinel del tipo inferido del argumento
(plantilla de función)

front_inserter

crea un std::front_insert_iterator del tipo inferido del argumento
(plantilla de función)

back_inserter

crea un std::back_insert_iterator del tipo inferido del argumento
(plantilla de función)

inserter

crea un std::insert_iterator del tipo inferido del argumento
(plantilla de función)

Operadores no miembros

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

(C++11) (C++11) (eliminado en C++20) (C++11) (C++11) (C++11) (C++11) (C++20)

compara los iteradores subyacentes
(plantilla de función)

operator+

(C++11)

avanza el iterador
(plantilla de función)

operator-

(C++11)

calcula la distancia entre dos adaptadores de iterador
(plantilla de función)

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

(C++20)

compara los iteradores subyacentes
(plantilla de función)

operator+

avanza el iterador
(plantilla de función)

operator-

calcula la distancia entre dos adaptadores de iterador
(plantilla de función)

operator== operator<=>

(C++20)

compara las distancias hasta el final
(plantilla de función)

operator+

(C++20)

avanza el iterador
(plantilla de función)

operator-

(C++20)

calcula la distancia entre dos adaptadores de iterador
(plantilla de función)

operator== operator!=

(eliminado en C++20)

compara dos


          istream_iterator

s
(plantilla de función)

operator== operator!=

(eliminado en C++20)

compara dos


          istreambuf_iterator

s
(plantilla de función)

Operaciones

advance

avanza un iterador una distancia determinada
(plantilla de función)

distance

devuelve la distancia entre dos iteradores
(plantilla de función)

(C++11)

incrementa un iterador
(plantilla de función)

(C++11)

decrementa un iterador
(plantilla de función)

ranges::advance

(C++20)

avanza un iterador una distancia determinada o hasta un límite dado
(objeto función de algoritmo)

ranges::distance

(C++20)

devuelve la distancia entre un iterador y un centinela, o entre el inicio y el final de un rango
(objeto función algoritmo)

ranges::next

(C++20)

incrementa un iterador por una distancia dada o hasta un límite
(objeto función de algoritmo)

ranges::prev

(C++20)

decrementa un iterador por una distancia dada o hasta un límite
(objeto función de algoritmo)

Acceso a rangos

begin cbegin

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

devuelve un iterador al inicio de un contenedor o array
(plantilla de función)

end cend

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

devuelve un iterador al final de un contenedor o array
(plantilla de función)

rbegin crbegin

(C++14)

devuelve un iterador inverso al inicio de un contenedor o array
(plantilla de función)

rend crend

(C++14)

devuelve un iterador inverso final para un contenedor o array
(plantilla de función)

size ssize

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

devuelve el tamaño de un contenedor o array
(plantilla de función)

empty

(C++17)

verifica si el contenedor está vacío
(plantilla de función)

data

(C++17)

obtiene el puntero al array subyacente
(plantilla de función)

Sinopsis

#include <compare>
#include <concepts>
namespace std {
  template<class T> using /* con-referencia */ = T&;  // exposición solamente
  template<class T> concept /* puede hacer referencia */       // exposición solamente
    = requires { typename /* con-referencia */<T>; };
  template<class T> concept /* dereferenceable */     // exposición solamente
    = requires(T& t) {
      { *t } -> /* puede-referenciar */;  // no se requiere que preserve la igualdad
    };
  // tipos asociados
  // rasgos incrementables
  template<class> struct incrementable_traits;
  template<class T>
    using iter_difference_t = /* ver descripción */;
  // rasgos indirectamente legibles
  template<class> struct indirectly_readable_traits;
  template<class T>
    using iter_value_t = /* ver descripción */;
  // rasgos del iterador
  template<class I> struct iterator_traits;
  template<class T> requires is_object_v<T> struct iterator_traits<T*>;
  template</* dereferenceable */ T>
    using iter_reference_t = decltype(*declval<T&>());
  namespace ranges {
    // customization point objects
    inline namespace /* sin especificar */ {
      // ranges::iter_move
      inline constexpr /* sin especificar */ iter_move = /* sin especificar */;
      // ranges::iter_swap
      inline constexpr /* sin especificar */ iter_swap = /* sin especificar */;
    }
  }
  template</* dereferenceable */ T>
    requires requires(T& t) {
      { ranges::iter_move(t) } -> /* puede-referenciar */;
    }
  using iter_rvalue_reference_t
    = decltype(ranges::iter_move(declval<T&>()));
  // conceptos de iterador
  // concepto indirectly_readable
  template<class In>
    concept indirectly_readable = /* ver descripción */;
  template<indirectly_readable T>
    using iter_common_reference_t =
      common_reference_t<iter_reference_t<T>, iter_value_t<T>&>;
  // concepto indirectly_writable
  template<class Out, class T>
    concept indirectly_writable = /* ver descripción */;
  // concepto weakly_incrementable
  template<class I>
    concept weakly_incrementable = /* ver descripción */;
  // concepto incrementable
  template<class I>
    concept incrementable = /* ver descripción */;
  // concepto input_or_output_iterator
  template<class I>
    concept input_or_output_iterator = /* ver descripción */;
  // concepto sentinel_for
  template<class S, class I>
    concept sentinel_for = /* ver descripción */;
  // concepto 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 = /* ver descripción */;
  // concepto input_iterator
  template<class I>
    concept input_iterator = /* ver descripción */;
  // concepto output_iterator
  template<class I, class T>
    concept output_iterator = /* ver descripción */;
  // concepto forward_iterator
  template<class I>
    concept forward_iterator = /* ver descripción */;
  // concepto bidirectional_iterator
  template<class I>
    concept bidirectional_iterator = /* ver descripción */;
  // concepto random_access_iterator
  template<class I>
    concept random_access_iterator = /* ver descripción */;
  // concepto contiguous_iterator
  template<class I>
    concept contiguous_iterator = /* ver descripción */;
  // requisitos de llamada indirecta
  // llamadas indirectas
  template<class F, class I>
    concept indirectly_unary_invocable = /* ver descripción */;
  template<class F, class I>
    concept indirectly_regular_unary_invocable = /* ver descripción */;
  template<class F, class I>
    concept indirect_unary_predicate = /* ver descripción */;
  template<class F, class I1, class I2>
    concept indirect_binary_predicate = /* ver descripción */;
  template<class F, class I1, class I2 = I1>
    concept indirect_equivalence_relation = /* ver descripción */;
  template<class F, class I1, class I2 = I1>
    concept indirect_strict_weak_order = /* ver descripción */;
  template<class F, class... Es>
    requires (indirectly_readable<Is> && ...) && invocable<F, iter_reference_t<Is>...>
      using indirect_result_t = invoke_result_t<F, iter_reference_t<Is>...>;
  // proyectado
  template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
    using projected = /* ver descripción */;
  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>&>>;
  // requisitos comunes de algoritmos
  // concepto indirectly_movable
  template<class In, class Out>
    concept indirectly_movable = /* ver descripción */;
  template<class In, class Out>
    concept indirectly_movable_storable = /* ver descripción */;
  // concepto indirectly_copyable
  template<class In, class Out>
    concept indirectly_copyable = /* ver descripción */;
  template<class In, class Out>
    concept indirectly_copyable_storable = /* ver descripción */;
  // concepto indirectly_swappable
  template<class I1, class I2 = I1>
    concept indirectly_swappable = /* ver descripción */;
  // concepto indirectly_comparable
  template<class I1, class I2, class R, class P1 = identity, class P2 = identity>
    concept indirectly_comparable = /* ver descripción */;
  // concepto permutable
  template<class I>
    concept permutable = /* ver descripción */;
  // concepto mergeable
  template<class I1, class I2, class Out,
      class R = ranges::less, class P1 = identity, class P2 = identity>
    concept mergeable = /* ver descripción */;
  // concepto ordenable
  template<class I, class R = ranges::less, class P = identity>
    concept sortable = /* ver descripción */;
  // primitivas
  // etiquetas de iterador
  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 { };
  // operaciones de iterador
  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);
  // operaciones de iterador de rango
  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);
  }
  // iteradores y centinelas predefinidos
  // iteradores inversos
  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;
  // insert iterators
  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);
  // iteradores y centinelas de movimiento
  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;
  // iteradores comunes
  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>>;
  // valor centinela por defecto
  struct default_sentinel_t;
  inline constexpr default_sentinel_t default_sentinel{};
  // iteradores contados
  template<input_or_output_iterator I> class counted_iterator;
  template<input_iterator I>
    requires /* ver descripción */
    struct iterator_traits<counted_iterator<I>>;
  // centinela inalcanzable
  struct unreachable_sentinel_t;
  inline constexpr unreachable_sentinel_t unreachable_sentinel{};
  // iteradores de flujo
  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;
  // acceso por rango
  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;
}

Concepto `indirectly_readable`

namespace std {
  template<class In>
    concept /*indirectlyReadableImpl*/ = // solo para exposición
      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>>
}

Concepto `indirectly_writable`

namespace std {
  template<class Out, class T>
    concept indirectly_writable =
      requires(Out&& o, T&& t) {
        *o = std::forward<T>(t); // no se requiere que preserve la igualdad
        *std::forward<Out>(o) = std::forward<T>(t);
        // no se requiere que preserve la igualdad
        const_cast<const iter_reference_t<Out>&&>(*o) =
        std::forward<T>(t); // no se requiere que preserve la igualdad
        const_cast<const iter_reference_t<Out>&&>(*std::forward<Out>(o)) =
        std::forward<T>(t); // no se requiere que preserve la igualdad
      };
}

Concepto `weakly_incrementable`

namespace std {
  template<class T>
    inline constexpr bool /*is_integer_like*/ = /* ver descripción */; // solo para exposición
  template<class T>
    inline constexpr bool /*is_signed_integer_like*/ =  // solo para exposición
      /* ver descripción */;
  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&>;   // no se requiere que preserve la igualdad
        i++;                      // no se requiere que preserve la igualdad
      };
}

Concepto `incrementable`

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

Concepto `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>>;
      };
}

Concepto `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>;
}

Concepto `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); // no se requiere que preserve la igualdad
      };
}

Concepto `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>;
}

Concepto `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>;
      };
}

Concepto `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>>;
      };
}

Concepto `contiguous_iterator`

namespace std {
  template<class I>
    concepto 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>>> &&
      requiere(const I& i) {
        { to_address(i) } -> same_as<add_pointer_t<iter_reference_t<I>>>;
      };
}

Concept `indirectly_unary_invocable`

namespace std {
  template<class F, class I>
    concepto 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>>>;
}

Concept `indirectly_regular_unary_invocable`

namespace std {
  template<class F, class I>
    concepto indirectamente_regular_unary_invocable =
      indirectamente_legible<I> &&
      copiable<F> &&
      regularmente_invocable<F&, iter_value_t<I>&> &&
      regularmente_invocable<F&, iter_reference_t<I>> &&
      referencia_comun_con<
        invoke_result_t<F&, iter_value_t<I>&>,
        invoke_result_t<F&, iter_reference_t<I>>>;
}

Concepto `indirect_unary_predicate`

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

Concepto `indirect_binary_predicate`

namespace std {
  template<class F, class I1, class I2 = I1>
    concepto 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>>;
}

Concept `indirect_equivalence_relation`

namespace std {
  template<class F, class I1, class I2 = I1>
    concepto indirect_equivalence_relation =
      indirectly_readable<I1> && indirectly_readable<I2> &&
      copy_constructible<F> &&
      equivalence_relation<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
      equivalence_relation<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
      equivalence_relation<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
      equivalence_relation<F&, iter_reference_t<I1>, iter_reference_t<I2>>;
}

Concepto `indirect_strict_weak_order`

namespace std {
  template<class F, class I1, class I2 = I1>
    concepto 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>>;
}

Concepto `indirectly_movable`

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

Concepto `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>>;
}

Concepto `indirectly_copyable`

namespace std {
  template<class In, class Out>
    concepto indirectamente_copiable =
      indirectamente_legible<In> &&
      indirectamente_escribible<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>>;
}

Concepto `indirectly_swappable`

namespace std {
  template<class I1, class I2 = I1>
    concepto indirectamente_intercambiable =
      indirectamente_legible<I1> && indirectamente_legible<I2> &&
      requiere(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);
      };
}

Concepto `indirectly_comparable`

namespace std {
  template<class I1, class I2, class R, class P1 = identity, class P2 = identity>
    concepto indirectamente_comparable =
      predicado_indirecto<R, projected<I1, P1>, projected<I2, P2>>;
}

Concepto `permutable`

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

Concepto `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>>;
}

Concepto `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>>;
}

Plantilla de clase 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 = /* ver descripción */;
}

Plantilla de clase std::indirectly_readable_traits

namespace std {
  template<class> struct /*cond_value_type*/ { };   // solo para exposición
  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> { };
}

Plantilla de clase std::projected

namespace std {
  template<class I, class Proj>
  struct /*projected-impl*/ {                        // solo para exposición
    struct /*type*/ {                                // solo para exposición
      using value_type = remove_cvref_t<indirect_result_t<Proj&, I>>;
      using difference_type = iter_difference_t<I>;  // presente solo si I
                                                     // modela weakly_incrementable
      indirect_result_t<Proj&, I> operator*() const; // no definido
    };
  };
  template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
  using projected = /*projected-impl*/<I, Proj>::/*type*/;
}

Plantilla de clase std::iterator_traits

namespace std {
  template<class I>
  struct iterator_traits {
    using iterator_category = /* ver descripción */;
    using value_type        = /* ver descripción */;
    using difference_type   = /* ver descripción */;
    using pointer           = /* ver descripción */;
    using reference         = /* ver descripción */;
  };
  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&;
  };
}

Etiquetas de iterador

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 { };
}

Plantilla de clase std::reverse_iterator

namespace std {
  template<class Iter>
  class reverse_iterator {
  public:
    using iterator_type     = Iter;
    using iterator_concept  = /* ver descripción */;
    using iterator_category = /* ver descripción */;
    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 /* ver descripción */;
    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 /* no especificado */ operator[](difference_type n) const;
    friend constexpr iter_rvalue_reference_t<Iter>
      iter_move(const reverse_iterator& i) noexcept(/* ver descripción */);
    template<indirectly_swappable<Iter> Iter2>
      friend constexpr void
        iter_swap(const reverse_iterator& x,
                  const reverse_iterator<Iter2>& y) noexcept(/* ver descripción */);
  protected:
    Iter current;
  };
}

Plantilla de clase 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);
  };
}

Plantilla de clase 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);
  };
}

Plantilla de clase 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);
  };
}

Plantilla de clase std::move_iterator

namespace std {
  template<class Iter>
  class move_iterator {
  public:
    using iterator_type     = Iter;
    using iterator_concept  = /* ver descripción */;
    using iterator_category = /* ver descripción */;
    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;     // solo para exposición
  };
}

Plantilla de clase 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;     // solo para exposición
  };
}

Plantilla de clase 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 /* ver descripción */;
    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
**Nota:** El texto ya está en inglés y contiene términos específicos de C++ (`ranges::iter_swap`) que no deben traducirse según las instrucciones. No hay contenido textual adicional para traducir al español.(declval<const I&>(), declval<const I2&>())));
  private:
    variant<I, S> v_;   // exposición solamente
  };
  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 = /* ver descripción */;
    using iterator_category = /* ver descripción */;
    using value_type = iter_value_t<I>;
    using difference_type = iter_difference_t<I>;
    using pointer = /* ver descripción */;
    using reference = iter_reference_t<I>;
  };
}

Clase std::default_sentinel_t

namespace std {
  struct default_sentinel_t { };
}

Plantilla de clase 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
(Nota: El texto ya está en inglés y contiene términos específicos de C++ que no deben traducirse según las instrucciones. El enlace y la estructura HTML se mantienen intactos)(x.current, y.current)));
  private:
    I current = I();                    // exposición solamente
    iter_difference_t<I> length = 0;    // exposición solamente
  };
  template<input_iterator I>
  struct iterator_traits<counted_iterator<I>> : iterator_traits<I> {
    using pointer = void;
  };
}

Clase 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; }
  };
}

Plantilla de clase 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; // solo para exposición
    T value;                                 // solo para exposición
  };
}

Plantilla de clase 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;          // solo para exposición
    const CharT* delim = nullptr;                                // solo para exposición
  };
}

Plantilla de clase 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           = /* no especificado */;
    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;                          // solo para exposición
    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_;                // solo para exposición
  };
  template<class CharT, class Traits>
  class istreambuf_iterator<CharT, Traits>::proxy { // solo para exposición
    CharT keep_;
    basic_streambuf<CharT, Traits>* sbuf_;
    proxy(CharT c, basic_streambuf<CharT, Traits>* sbuf)
      : keep_(c), sbuf_(sbuf) { }
  public:
    CharT operator*() { return keep_; }
  };
}

Plantilla de clase 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;    // solo para exposición
  };
}

Plantilla de clase 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;
  };
}

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

DR	Aplicado a	Comportamiento publicado	Comportamiento correcto
LWG 349	C++98	el miembro solo de exposición `delim` de std::ostream_iterator tenía tipo const char *	corregido a 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>

Contenidos

Conceptos

Conceptos de iterador

Conceptos de invocación indirecta

Requisitos comunes de algoritmos

Clases

Utilidades de algoritmos

Tipos asociados

Primitivos

Adaptadores

Iteradores de Flujo

Objetos de punto de personalización

Constantes

Funciones

Adaptadores

Operadores no miembros

Operaciones

Acceso a rangos

Sinopsis

Concepto indirectly_readable

Concepto indirectly_writable

Concepto weakly_incrementable

Concepto incrementable

Concepto input_or_output_iterator

Concept sentinel_for

Concept sized_sentinel_for

Concepto input_iterator

Concepto output_iterator

Concepto forward_iterator

Concepto bidirectional_iterator

Concepto random_access_iterator

Concepto contiguous_iterator

Concept indirectly_unary_invocable

Concept indirectly_regular_unary_invocable

Concepto indirect_unary_predicate

Concepto indirect_binary_predicate

Concept indirect_equivalence_relation

Concepto indirect_strict_weak_order

Concepto indirectly_movable

Concepto indirectly_movable_storable

Concepto indirectly_copyable

Concept indirectly_copyable_storable

Concepto indirectly_swappable

Concepto indirectly_comparable

Concepto permutable

Concepto mergeable

Concepto sortable

Plantilla de clase std::incrementable_traits

Plantilla de clase std::indirectly_readable_traits

Plantilla de clase std::projected

Plantilla de clase std::iterator_traits

Etiquetas de iterador

Plantilla de clase std::reverse_iterator

Plantilla de clase std::back_insert_iterator

Plantilla de clase std::front_insert_iterator

Plantilla de clase std::insert_iterator

Plantilla de clase std::move_iterator

Plantilla de clase std::move_sentinel

Plantilla de clase std::common_iterator

Clase std::default_sentinel_t

Plantilla de clase std::counted_iterator

Clase std::unreachable_sentinel_t

Plantilla de clase std::istream_iterator

Plantilla de clase std::ostream_iterator

Plantilla de clase std::istreambuf_iterator

Plantilla de clase std::ostreambuf_iterator

Plantilla de clase std::iterator

Informes de defectos

Concepto `indirectly_readable`

Concepto `indirectly_writable`

Concepto `weakly_incrementable`

Concepto `incrementable`

Concepto `input_or_output_iterator`

Concept `sentinel_for`

Concept `sized_sentinel_for`

Concepto `input_iterator`

Concepto `output_iterator`

Concepto `forward_iterator`

Concepto `bidirectional_iterator`

Concepto `random_access_iterator`

Concepto `contiguous_iterator`

Concept `indirectly_unary_invocable`

Concept `indirectly_regular_unary_invocable`

Concepto `indirect_unary_predicate`

Concepto `indirect_binary_predicate`

Concept `indirect_equivalence_relation`

Concepto `indirect_strict_weak_order`

Concepto `indirectly_movable`

Concepto `indirectly_movable_storable`

Concepto `indirectly_copyable`

Concept `indirectly_copyable_storable`

Concepto `indirectly_swappable`

Concepto `indirectly_comparable`

Concepto `permutable`

Concepto `mergeable`

Concepto `sortable`