Archivo de encabezado de la biblioteca estándar <iterator>

De cppreference.com

Este archivo de encabezado es parte de la biblioteca de iteradores.

Plantilla:cpp/iterator/dsc IndirectlyMovable Plantilla:cpp/iterator/dsc IndirectlyMovableStorable Plantilla:cpp/iterator/dsc IndirectlyCopyable Plantilla:cpp/iterator/dsc IndirectlyCopyableStorable

Contenido

Conceptos

Conceptos de iterador

indirectly_readable

Especifica que un tipo puede leerse indirectamente al aplicar el operador *.
(concepto) [editar]

indirectly_writable

Especifica que un valor puede escribirse al objeto referenciado por un iterador.
(concepto) [editar]

weakly_incrementable

Especifica que un tipo [[cpp/concepto no reconocido/Semiregular|Semiregular]] puede incrementarse con operadores de preincremento y posincremento.
(concepto) [editar]

incrementable

Especifica que la operación de incremento en un tipo weakly_incrementable es conservadora de igualdad y que el tipo es equality_comparable.
(concepto) [editar]

input_or_output_iterator

Especifica que los objetos de un tipo pueden incrementarse y desreferenciarse.
(concepto) [editar]

sentinel_for

Especifica que un tipo es un centinela para un tipo input_or_output_iterator.
(concepto) [editar]

sized_sentinel_for

Especifica que el operador aditivo de substracción - puede aplicarse a un iterador y un centinela para calcular su diferencia en tiempo constante.
(concepto) [editar]

input_iterator

Especifica que un tipo es un iterador de entrada. Es decir, sus valores referenciados pueden leerse y ser tanto preincrementados como posincrementados.
(concepto) [editar]

output_iterator

Especifica que un tipo es un iterador de salida para un tipo de valor dado. Es decir, los valores de ese tipo pueden ser escritos y pueden ser tanto preincrementados como posincrementados.
(concepto) [editar]

forward_iterator

(C++20)

Especifica que un input_iterator es un iterador de avance, que admite la comparación de igualdad y múltiples pasadas.
(concepto) [editar]

bidirectional_iterator

Especifica que un forward_iterator es un iterador bidireccional que puede retroceder.
(concepto) [editar]

random_access_iterator

(C++20)

Especifica que un bidirectional_iterator es un iterador de acceso aleatorio, que admite el avance en tiempo constante y acceso de subíndice.
(concepto) [editar]

contiguous_iterator

Especifica que un random_access_iterator es un iterador contiguo, refiriéndose a los elementos que se encuentran contiguos en memoria.
(concepto) [editar]

Conceptos invocables indirectos

indirectly_unary_invocableindirectly_regular_unary_invocable

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

Especifica que se puede invocar un tipo invocable con el resultado de eliminar la referencia a un tipo indirectly_readable.
(concepto) [editar]

indirect_unary_predicate

(C++20)

Especifica que un tipo invocable, cuando se invoca con el resultado de desreferenciar un tipo indirectly_readable, satisface a predicate
(concepto) [editar]

indirect_binary_predicate

(C++20)

Especifica que un tipo invocable, cuando se invoca con el resultado de desreferenciar dos tipos indirectly_readable, satisface a predicate
(concepto) [editar]

indirect_equivalence_relation

(C++20)

Especifica que un tipo invocable, cuando se invoca con el resultado de desreferenciar dos tipos indirectly_readable, satisface a equivalence_relation
(concepto) [editar]

indirect_strict_weak_order

(C++20)

Especifica que un tipo invocable, cuando se invoca con el resultado de desreferenciar dos tipos indirectly_readable, satisface a strict_weak_order
(concepto) [editar]

Requerimientos comunes de algoritmos

indirectly_swappable

(C++20)

Especifica que los valores referenciados por dos tipos indirectly_readable pueden intercambiarse
(concepto) [editar]

indirectly_comparable

(C++20)

Especifica que los valores referenciados por dos tipos indirectly_readable pueden compararse
(concepto) [editar]

permutable

(C++20)

Especifica los requerimientos comunes de los algoritmos que reordenan elementos en su lugar
(concepto) [editar]

mergeable

(C++20)

Especifica los requerimientos de los algoritmos que fusionan secuencias ordenadas en una secuencia de salida copiando elementos
(concepto) [editar]

sortable

(C++20)

Especifica los requerimientos comunes de los algoritmos que permutan secuencias en secuencias ordenadas
(concepto) [editar]

Clases

Utilerías de algoritmos

indirect_result_t

(C++20)

Calcula el resultado de invocar un tipo invocable sobre el resultado de desreferenciar algún conjunto de tipos indirectly_readable
(plantilla de alias) [editar]

projected

(C++20)

Plantilla asistente para especificar las restricciones de algoritmos que aceptan proyecciones
(plantilla de clase) [editar]

Tipos asociados

incrementable_traits

Calcula el tipo diferencia de un tipo weakly_incrementable.
(plantilla de clase) [editar]

indirectly_readable_traits

Calcula el tipo del valor de un tipo indirectly_readable.
(plantilla de clase) [editar]

iter_value_titer_reference_titer_difference_titer_rvalue_reference_titer_common_reference_t

Calcula los tipos asociados de un iterador.
(plantilla de alias) [editar]

Primitivas

iterator_traits

Proporciona una interfaz uniforme para las propiedades de un iterador.
(plantilla de clase) [editar]

input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tag

Tipos clase vacíos para indicar categorías de iteradores.
(clase) [editar]

iterator

El iterador básico.
(plantilla de clase) [editar]

Adaptadores

reverse_iterator

Adaptador de iterador para recorrido en orden inverso.
(plantilla de clase) [editar]

move_iterator

(C++11)

Adaptador de iterador que se desreferencia a una referencia rvalue.
(plantilla de clase) [editar]

move_sentinel

(C++20)

Adaptador de centinela para uso con std::move_iterator
(plantilla de clase) [editar]

common_iterator

(C++20)

Adapta un tipo de iterador y su centinela a un tipo de iterador común.
(plantilla de clase) [editar]

default_sentinel_t

(C++20)

Centinela por defecto para uso con iteradores que conocen el límite de su rango.
(clase) [editar]

counted_iterator

(C++20)

Adaptador de iterador que rastrea la distancia hasta el final del rango.
(plantilla de clase) [editar]

unreachable_sentinel_t

(C++20)

Centinela que siempre se compara desigual a cualquier tipo [[cpp/concepto no reconocido/WeaklyIncrementable|WeaklyIncrementable]].
(clase) [editar]

back_insert_iterator

Adaptador de iterador para la inserción al final de un contenedor.
(plantilla de clase) [editar]

front_insert_iterator

Adaptador de iterador para la inserción en la parte frontal de un contenedor.
(plantilla de clase) [editar]

insert_iterator

Adaptador de iterador para la inserción en un contenedor.
(plantilla de clase) [editar]

Iteradores de flujos

istream_iterator

Iterador de entrada que lee de un flujo de entrada (std::basic_istream).
(plantilla de clase) [editar]

ostream_iterator

Iterador de salida que escribe a un flujo de salida (std::basic_ostream).
(plantilla de clase) [editar]

istreambuf_iterator

Iterador de entrada que lee de un búfer de flujo (std::basic_streambuf).
(plantilla de clase) [editar]

ostreambuf_iterator

Iterador de salida que escribe a un búfer de flujo (std::basic_streambuf).
(plantilla de clase) [editar]

Objetos de punto de personalización

Definido en el espacio de nombres std::ranges

iter_move

Convierte el resultado de desreferenciar un objeto a su tipo asociado de referencia rvalue.
(objeto punto de personalización) [editar]

iter_swap

(C++20)

Intercambia los valores referenciados por dos objetos desreferenciables.
(objeto punto de personalización) [editar]

Funciones

Adaptors

make_reverse_iterator

(C++14)

Crea un std::reverse_iterator del tipo inferido a partir del argumento.
(plantilla de función) [editar]

make_move_iterator

(C++11)

Crea un std::move_iterator del tipo inferido a partir del argumento.
(plantilla de función) [editar]

front_inserter

Crea un std::front_insert_iterator de tipo inferido a partir del argumento.
(plantilla de función) [editar]

back_inserter

Crea un std::back_insert_iterator de tipo inferido a partir del argumento.
(plantilla de función) [editar]

inserter

Crea un std::insert_iterator de tipo inferido a partir del argumento.
(plantilla de función) [editar]

Operadores no miembro

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

compara los iteradores subyacentes
(plantilla de función) [editar]

operator+

avanza el iterador

(plantilla de función) [editar]

operator-

calcula la distancia entre dos adaptadores iterador

(plantilla de función) [editar]

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

compara los iteradores subyacentes
(plantilla de función) [editar]

operator+

avanza el iterador

(plantilla de función) [editar]

operator-

calcula la distancia entre dos adaptadores iterador

(plantilla de función) [editar]

operator==operator!=

compara dos istream_iterator
(plantilla de función) [editar]

operator==operator!=

compara dos istreambuf_iterator
(plantilla de función) [editar]

Operaciones

advance

Avanza un iterador en una distancia determinada.
(función) [editar]

distance

Devuelve la distancia entre dos iteradores.
(función) [editar]

(C++11)

Incrementa un iterador.
(función) [editar]

(C++11)

Decrementa un iterador.
(función) [editar]

ranges::advance

(C++20)

Avanza un iterador en una distancia dada o a un límite dado.
(niebloid) [editar]

ranges::distance

(C++20)

Devuelve la distancia entre un iterador y un centinela, o entre el principio y el fin de un rango.
(niebloid) [editar]

ranges::next

(C++20)

Incrementa un iterador en una distancia dada o a un límite.
(niebloid) [editar]

ranges::prev

(C++20)

Decrementa un iterador en una distancia dada o a un límite.
(niebloid) [editar]

Acceso a rangos

begincbegin

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

Devuelve un iterator al comienzo de un contenedor o array.
(plantilla de función) [editar]

endcend

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

Devuelve un iterator al final de un contenedor o array
(plantilla de función) [editar]

rbegincrbegin

(C++14)

Devuelve un iterador inverso al contenedor o array
(plantilla de función) [editar]

rendcrend

(C++14)

Devuelve un iterador inverso al final para un contenedor o array
(plantilla de función) [editar]

sizessize

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

Devuelve el tamaño de un contenedor o un array.
(plantilla de función) [editar]

empty

(C++17)

Comprueba si un contenedor está vacío
(plantilla de función) [editar]

data

(C++17)

Obtiene el puntero al array subyacente.
(plantilla de función) [editar]

[editar] Sinopsis

#include <concepts>
 
namespace std {
  template<class T> using __with_reference = T&;  // solo exposición
  template<class T> concept __Referenceable       // solo exposición
    = requires { typename __with_reference<T>; };
  template<class T> concept __Dereferenceable     // solo exposición
    = requires(T& t) {
      { *t } -> __Referenceable;  // no se requiere que conserve la igualdad
    };
 
  // tipos asociados
  // rasgos incrementables
  template<class> struct incrementable_traits;
  template<class T>
    using iter_difference_t = /* véase descripción */;
 
  // rasgos indirectamente legibles
  template<class> struct indirectly_readable_traits;
  template<class T>
    using iter_value_t = /* véase descripción */;
 
  // rasgos de 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 {
    // puntos de personalización
    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) } -> __Referenceable;
    }
  using iter_rvalue_reference_t
    = decltype(ranges::iter_move(declval<T&>()));
 
  // conceptos de iterador
  // concepto indirectly_readable
  template<class In>
    concept indirectly_readable = /* véase 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 = /* véase descripción */;
 
  // concepto weakly_incrementable
  template<class I>
    concept weakly_incrementable = /* véase descripción */;
 
  // concepto incrementable
  template<class I>
    concept incrementable = /* véase descripción */;
 
  // concepto input_or_output_iterator
  template<class I>
    concept input_or_output_iterator = /* véase descripción */;
 
  // concepto sentinel_for
  template<class S, class I>
    concept sentinel_for = /* véase descripción */;
 
  // concepto sized_sentinel_for
  template<class S, class I>
    inline constexpr bool disable_sized_sentinel = false;
 
  template<class S, class I>
    concept sized_sentinel_for = /* véase descripción */;
 
  // concepto input_iterator
  template<class I>
    concept input_iterator = /* véase descripción */;
 
  // concepto output_iterator
  template<class I, class T>
    concept output_iterator = /* véase descripción */;
 
  // concepto forward_iterator
  template<class I>
    concept forward_iterator = /* véase descripción */;
 
  // concepto bidirectional_iterator
  template<class I>
    concept bidirectional_iterator = /* véase descripción */;
 
  // concepto random_access_iterator
  template<class I>
    concept random_access_iterator = /* véase descripción */;
 
  // concepto contiguous_iterator
  template<class I>
    concept contiguous_iterator = /* véase descripción */;
 
  // requerimientos de invocable indirecto
  // invocables indirectos
  template<class F, class I>
    concept indirectly_unary_invocable = /* véase descripción */;
 
  template<class F, class I>
    concept indirectly_regular_unary_invocable = /* véase descripción */;
 
  template<class F, class I>
    concept indirect_unary_predicate = /* véase descripción */;
 
  template<class F, class I1, class I2>
    concept indirect_binary_predicate = /* véase descripción */;
 
  template<class F, class I1, class I2 = I1>
    concept indirect_equivalence_relation = /* véase descripción */;
 
  template<class F, class I1, class I2 = I1>
    concept indirect_strict_weak_order = /* véase descripción */;
 
  template<class F, class... Is>
    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>
    struct projected;
 
  template<weakly_incrementable I, class Proj>
    struct incrementable_traits<projected<I, Proj>>;
 
  // requerimientos comunes de algoritmos
  // concepto indirectly_movable
  template<class In, class Out>
    concept indirectly_movable = /* véase descripción */;
 
  template<class In, class Out>
    concept indirectly_movable_storable = /* véase descripción */;
 
  // concepto indirectly_copyable
  template<class In, class Out>
    concept indirectly_copyable = /* véase descripción */;
 
  template<class In, class Out>
    concept indirectly_copyable_storable = /* véase descripción */;
 
  // concepto indirectly_swappable
  template<class I1, class I2 = I1>
    concept indirectly_swappable = /* véase descripción */;
 
  // concepto indirectly_comparable
  template<class I1, class I2, class R, class P1 = identity, class P2 = identity>
    concept indirectly_comparable = /* véase descripción */;
 
  // concepto permutable
  template<class I>
    concept permutable = /* véase descripción */;
 
  // concepto mergeable
  template<class I1, class I2, class Out,
      class R = ranges::less, class P1 = identity, class P2 = identity>
    concept mergeable = /* véase descripción */;
 
  // concepto sortable
  template<class I, class R = ranges::less, class P = identity>
    concept sortable = /* véase 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 InputIter, class Distance>
    constexpr void
      advance(InputIter& i, Distance n);
  template<class InputIter>
    constexpr typename iterator_traits<InputIter>::difference_type
      distance(InputIter first, InputIter last);
  template<class InputIter>
    constexpr InputIter
      next(InputIter x, typename iterator_traits<InputIter>::difference_type n = 1);
  template<class BidirectionalIter>
    constexpr BidirectionalIter
      prev(BidirectionalIter x,
           typename iterator_traits<BidirectionalIter>::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<input_or_output_iterator I, sentinel_for<I> S>
      constexpr iter_difference_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 Iter> class reverse_iterator;
 
  template<class Iter1, class Iter2>
    constexpr bool operator==(
      const reverse_iterator<Iter1>& x,
      const reverse_iterator<Iter2>& y);
  template<class Iter1, class Iter2>
    constexpr bool operator!=(
      const reverse_iterator<Iter1>& x,
      const reverse_iterator<Iter2>& y);
  template<class Iter1, class Iter2>
    constexpr bool operator<(
      const reverse_iterator<Iter1>& x,
      const reverse_iterator<Iter2>& y);
  template<class Iter1, class Iter2>
    constexpr bool operator>(
      const reverse_iterator<Iter1>& x,
      const reverse_iterator<Iter2>& y);
  template<class Iter1, class Iter2>
    constexpr bool operator<=(
      const reverse_iterator<Iter1>& x,
      const reverse_iterator<Iter2>& y);
  template<class Iter1, class Iter2>
    constexpr bool operator>=(
      const reverse_iterator<Iter1>& x,
      const reverse_iterator<Iter2>& y);
  template<class Iter1, three_way_comparable_with<Iter1> Iter2>
    constexpr compare_three_way_result_t<Iter1, Iter2>
      operator<=>(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);
 
  template<class Iter1, class Iter2>
    constexpr auto operator-(
      const reverse_iterator<Iter1>& x,
      const reverse_iterator<Iter2>& y) -> decltype(y.base() - x.base());
  template<class Iter>
    constexpr reverse_iterator<Iter>
      operator+(
    typename reverse_iterator<Iter>::difference_type n,
    const reverse_iterator<Iter>& x);
 
  template<class Iter>
    constexpr reverse_iterator<Iter> make_reverse_iterator(Iter i);
 
  template<class Iter1, class Iter2>
      requires (!sized_sentinel_for<Iter1, Iter2>)
    inline constexpr bool disable_sized_sentinel<reverse_iterator<Iter1>,
                                                 reverse_iterator<Iter2>> = true;
 
  // iteradores de inserción
  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 Iter> class move_iterator;
 
  template<class Iter1, class Iter2>
    constexpr bool operator==(
      const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
  template<class Iter1, class Iter2>
    constexpr bool operator<(
      const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
  template<class Iter1, class Iter2>
    constexpr bool operator>(
      const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
  template<class Iter1, class Iter2>
    constexpr bool operator<=(
      const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
  template<class Iter1, class Iter2>
    constexpr bool operator>=(
      const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
  template<class Iter1, three_way_comparable_with<Iter1> Iter2>
    constexpr compare_three_way_result_t<Iter1, Iter2>
      operator<=>(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);
 
  template<class Iter1, class Iter2>
    constexpr auto operator-(
    const move_iterator<Iter1>& x,
    const move_iterator<Iter2>& y) -> decltype(x.base() - y.base());
  template<class Iter>
    constexpr move_iterator<Iter> operator+(
      typename move_iterator<Iter>::difference_type n, const move_iterator<Iter>& x);
 
  template<class Iter>
    constexpr move_iterator<Iter> make_move_iterator(Iter i);
 
  template<semiregular S> class move_sentinel;
 
  // iteradores comunes
  template<input_or_output_iterator I, sentinel_for<I> S>
    requires (!same_as<I, S>)
      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>>;
 
  // centinelas 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<class I>
    struct incrementable_traits<counted_iterator<I>>;
 
  template<input_iterator I>
    struct iterator_traits<counted_iterator<I>>;
 
  // centinelas inalcanzables
  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 a rangos
  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> [[nodiscard]] constexpr auto empty(const C& c) -> decltype(c.empty());
  template<class T, size_t N> [[nodiscard]] constexpr bool empty(const T (&a)[N]) noexcept;
  template<class E> [[nodiscard]] 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;
}

[editar] Concepto `indirectly_readable`

namespace std {
  template<class In>
    concept __IndirectlyReadableImpl = // solo 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>>
}

[editar] 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 conserve la igualdad
        *std::forward<Out>(o) = std::forward<T>(t);
        // no se requiere que conserve la igualdad
        const_cast<const iter_reference_t<Out>&&>(*o) =
        std::forward<T>(t); // no se requiere que conserve la igualdad
        const_cast<const iter_reference_t<Out>&&>(*std::forward<Out>(o)) =
        std::forward<T>(t); // no se requiere que conserve la igualdad
      };
}

[editar] Concepto `weakly_incrementable`

namespace std {
  template<class T>
    inline constexpr bool __is_integer_like = /* véase descripción */; // solo exposición
 
  template<class T>
    inline constexpr bool __is_signed_integer_like =  // solo exposición
      /* véase 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 conserve la igualdad
        i++;                      // no se requiere que conserve la igualdad
      };
}

[editar] Concepto `incrementable`

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

[editar] Concepto `input_or_output_iterator`

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

[editar] Concepto `sentinel_for`

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

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

[editar] Concepto `input_iterator`

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

[editar] 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 conserve la igualdad
      };
}

[editar] Concepto `forward_iterator`

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

[editar] Concepto `bidirectional_iterator`

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

[editar] Concepto `random_access_iterator`

namespace std {
  template<class I>
    concept random_access_iterator =
      bidirectional_iterator<I> &&
      derived_from</*CONCEPTO_ITER*/(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>>;
      };
}

[editar] Concepto `contiguous_iterator`

namespace std {
  template<class I>
    concept contiguous_iterator =
      random_access_iterator<I> &&
      derived_from</*CONCEPTO_ITER*/(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>>>;
      };
}

[editar] Concepto `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>> &&
      invocable<F&, iter_common_reference_t<I>> &&
      common_reference_with<
        invoke_result_t<F&, iter_value_t<I>&>,
        invoke_result_t<F&, iter_reference_t<I>>>;
}

[editar] Concepto `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>> &&
      regular_invocable<F&, iter_common_reference_t<I>> &&
      common_reference_with<
        invoke_result_t<F&, iter_value_t<I>&>,
        invoke_result_t<F&, iter_reference_t<I>>>;
}

[editar] Concepto `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>> &&
      predicate<F&, iter_common_reference_t<I>>;
}

[editar] Concepto `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>> &&
      predicate<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
}

[editar] Concepto `indirect_equivalence_relation`

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

[editar] Concepto `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>> &&
      strict_weak_order<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
}

[editar] Concepto `indirectly_movable`

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

[editar] 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>>;
}

[editar] Concepto `indirectly_copyable`

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

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

[editar] Concepto `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);
      };
}

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

[editar] Concepto `permutable`

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

[editar] 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>>;
}

[editar] 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>>;
}

[editar] 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 = /* véase descripción */;
}

[editar] Plantilla de clase std::indirectly_readable_traits

namespace std {
  template<class> struct __cond_value_type { };   // solo 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> { };
}

[editar] Plantilla de clase std::projected

namespace std {
  template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
  struct projected {
    using value_type = remove_cvref_t<indirect_result_t<Proj&, I>>;
    indirect_result_t<Proj&, I> operator*() const; // not defined
  };
 
  template<weakly_incrementable I, class Proj>
  struct incrementable_traits<projected<I, Proj>> {
    using difference_type = iter_difference_t<I>;
  };
}

[editar] Plantilla de clase std::iterator_traits

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

[editar] 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 { };
}

[editar] Plantilla de clase std::reverse_iterator

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

[editar] 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);
  };
}

[editar] 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);
  };
}

[editar] 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);
  };
}

[editar] Plantilla de clase std::move_iterator

namespace std {
  template<class Iter>
  class move_iterator {
  public:
    using iterator_type     = Iter;
    using iterator_concept  = input_iterator_tag;
    using iterator_category = /* véase 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 exposición
  };
}

[editar] 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 exposición
  };
}

[editar] Plantilla de clase std::common_iterator

namespace std {
  template<input_or_output_iterator I, sentinel_for<I> S>
    requires (!same_as<I, S>)
  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 /* véase 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 iter_rvalue_reference_t<I> 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_;   // solo exposición
  };
 
  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 = /* véase descripción */;
    using iterator_category = /* véase descripción */;
    using value_type = iter_value_t<I>;
    using difference_type = iter_difference_t<I>;
    using pointer = /* véase descripción */;
    using reference = iter_reference_t<I>;
  };
}

[editar] Clase std::default_sentinel_t

namespace std {
  struct default_sentinel_t { };
}

[editar] 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 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 iter_rvalue_reference_t<I> 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();                    // solo exposición
    iter_difference_t<I> length = 0;    // solo exposición
  };
 
  template<class I>
  struct incrementable_traits<counted_iterator<I>> {
    using difference_type = iter_difference_t<I>;
  };
 
  template<input_iterator I>
  struct iterator_traits<counted_iterator<I>> : iterator_traits<I> {
    using pointer = void;
  };
}

[editar] 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; }
  };
}

[editar] 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 exposición
    T value;                                 // solo exposición
  };
}

[editar] 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 exposición
    const CharT* delim = nullptr;                                // solo exposición
  };
}

[editar] 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           = /* sin especificar */;
    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 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 exposición
  };
 
  template<class CharT, class Traits>
  class istreambuf_iterator<CharT, Traits>::proxy { // solo 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_; }
  };
}

[editar] 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 exposición
  };
}

[editar] 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;
  };
}

Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/header/iterator&oldid=36713»

Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas

cppreference.com

Espacios de nombres

Variantes

Vistas

Acciones

Archivo de encabezado de la biblioteca estándar <iterator>

Contenido

Conceptos

Conceptos de iterador

Conceptos invocables indirectos

Requerimientos comunes de algoritmos

Clases

Utilerías de algoritmos

Tipos asociados

Primitivas

Adaptadores

Iteradores de flujos

Objetos de punto de personalización

Funciones

Adaptors

Operadores no miembro

Operaciones

Acceso a rangos

[editar] Sinopsis

[editar] Concepto indirectly_readable

[editar] Concepto indirectly_writable

[editar] Concepto weakly_incrementable

[editar] Concepto incrementable

[editar] Concepto input_or_output_iterator

[editar] Concepto sentinel_for

[editar] Concepto sized_sentinel_for

[editar] Concepto input_iterator

[editar] Concepto output_iterator

[editar] Concepto forward_iterator

[editar] Concepto bidirectional_iterator

[editar] Concepto random_access_iterator

[editar] Concepto contiguous_iterator

[editar] Concepto indirectly_unary_invocable

[editar] Concepto indirectly_regular_unary_invocable

[editar] Concepto indirect_unary_predicate

[editar] Concepto indirect_binary_predicate

[editar] Concepto indirect_equivalence_relation

[editar] Concepto indirect_strict_weak_order

[editar] Concepto indirectly_movable

[editar] Concepto indirectly_movable_storable

[editar] Concepto indirectly_copyable

[editar] Concepto indirectly_copyable_storable

[editar] Concepto indirectly_swappable

[editar] Concepto indirectly_comparable

[editar] Concepto permutable

[editar] Concepto mergeable

[editar] Concepto sortable

[editar] Plantilla de clase std::incrementable_traits

[editar] Plantilla de clase std::indirectly_readable_traits

[editar] Plantilla de clase std::projected

[editar] Plantilla de clase std::iterator_traits

[editar] Etiquetas de iterador

[editar] Plantilla de clase std::reverse_iterator

[editar] Plantilla de clase std::back_insert_iterator

[editar] Plantilla de clase std::front_insert_iterator

[editar] Plantilla de clase std::insert_iterator

[editar] Plantilla de clase std::move_iterator

[editar] Plantilla de clase std::move_sentinel

[editar] Plantilla de clase std::common_iterator

[editar] Clase std::default_sentinel_t

[editar] Plantilla de clase std::counted_iterator

[editar] Clase std::unreachable_sentinel_t

[editar] Plantilla de clase std::istream_iterator

[editar] Plantilla de clase std::ostream_iterator

[editar] Plantilla de clase std::istreambuf_iterator

[editar] Plantilla de clase std::ostreambuf_iterator

[editar] Plantilla de clase std::iterator

Navegación

Herramientas

[editar] Concepto `indirectly_readable`

[editar] Concepto `indirectly_writable`

[editar] Concepto `weakly_incrementable`

[editar] Concepto `incrementable`

[editar] Concepto `input_or_output_iterator`

[editar] Concepto `sentinel_for`

[editar] Concepto `sized_sentinel_for`

[editar] Concepto `input_iterator`

[editar] Concepto `output_iterator`

[editar] Concepto `forward_iterator`

[editar] Concepto `bidirectional_iterator`

[editar] Concepto `random_access_iterator`

[editar] Concepto `contiguous_iterator`

[editar] Concepto `indirectly_unary_invocable`

[editar] Concepto `indirectly_regular_unary_invocable`

[editar] Concepto `indirect_unary_predicate`

[editar] Concepto `indirect_binary_predicate`

[editar] Concepto `indirect_equivalence_relation`

[editar] Concepto `indirect_strict_weak_order`

[editar] Concepto `indirectly_movable`

[editar] Concepto `indirectly_movable_storable`

[editar] Concepto `indirectly_copyable`

[editar] Concepto `indirectly_copyable_storable`

[editar] Concepto `indirectly_swappable`

[editar] Concepto `indirectly_comparable`

[editar] Concepto `permutable`

[editar] Concepto `mergeable`

[editar] Concepto `sortable`