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

 

C++

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

 

Archivos de encabezado de la biblioteca estándar

Apoyo del lenguaje <cfloat> <climits> <compare> (C++20) <coroutine> (C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint> (C++11) <cstdlib> <exception> <initializer_list> (C++11)    <limits> <new> <source_location> (C++20) <stdfloat> (C++23) <typeinfo> <version> (C++20) Conceptos <concepts> (C++20) Diagnósticos <cassert> <cerrno> <debugging> (C++26) <stacktrace> (C++23) <stdexcept> <system_error> (C++11) Gestión de memoria <memory> <memory_resource> (C++17) <scoped_allocator> (C++11) Metaprogramación <type_traits> (C++11) <ratio> (C++11)

Servicios generales <any> (C++17) <bitset> <bit> (C++20) <charconv> (C++17) <expected> (C++23) <format> (C++20) <functional> <optional> (C++17) <tuple> (C++11) <typeindex> (C++11) <utility> <variant> (C++17) Contenedores <array> (C++11) <deque> <flat_map> (C++23) <flat_set> (C++23) <forward_list> (C++11) <inplace_vector> (C++26)    <list> <map> <mdspan> (C++23) <queue> <set> <span> (C++20) <stack> <unordered_map> (C++11) <unordered_set> (C++11) <vector> Iteradores <iterator> Rangos <generator> (C++23) <ranges> (C++20)

Algoritmos <algorithm> <numeric> Cadenas <cctype> <cstring> <cuchar> (C++11) <cwchar> <cwctype> <string_view> (C++17) <string> Procesamiento de texto <clocale> <codecvt> (C++11/17/26*) <locale> <regex> (C++11) <text_encoding> (C++26)    Numéricos <cfenv> (C++11) <cmath> <complex> <linalg> (C++26) <numbers> (C++20) <random> (C++11) <simd> (C++26) <valarray> Tiempo <chrono> (C++11) <ctime> Compatibilidad con C <ccomplex> (C++11/17/20*) <ciso646> (hasta C++20) <cstdalign> (C++11/17/20*) <cstdbool> (C++11/17/20*) <ctgmath> (C++11/17/20*)

Entrada/Salida <cinttypes> (C++11) <cstdio> <filesystem> (C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print> (C++23) <spanstream> (C++23) <sstream> <streambuf> <strstream> (C++98/26*) <syncstream> (C++20) Apoyo para concurrencia <atomic> (C++11) <barrier> (C++20) <condition_variable> (C++11) <future> (C++11) <hazard_pointer> (C++26) <latch> (C++20) <mutex> (C++11) <rcu> (C++26) <semaphore> (C++20) <shared_mutex> (C++14) <stdatomic.h> (C++23) <stop_token> (C++20) <thread> (C++11) Apoyo de ejecución <execution> (C++17)

 

See More

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

Plantilla:cpp/iterator/dsc IndirectlyMovablePlantilla:cpp/iterator/dsc IndirectlyMovableStorablePlantilla:cpp/iterator/dsc IndirectlyCopyablePlantilla:cpp/iterator/dsc IndirectlyCopyableStorable

Conceptos
Conceptos de iterador
indirectly_readable	Especifica que un tipo puede leerse indirectamente al aplicar el operador *. (concepto)
indirectly_writable	Especifica que un valor puede escribirse al objeto referenciado por un iterador. (concepto)
weakly_incrementable	Especifica que un tipo [[cpp//Semiregular|Semiregular]] puede incrementarse con operadores de preincremento y posincremento. (concepto)
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)
input_or_output_iterator	Especifica que los objetos de un tipo pueden incrementarse y desreferenciarse. (concepto)
sentinel_for	Especifica que un tipo es un centinela para un tipo input_or_output_iterator. (concepto)
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)
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)
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)
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)
bidirectional_iterator	Especifica que un forward_iterator es un iterador bidireccional que puede retroceder. (concepto)
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)
contiguous_iterator	Especifica que un random_access_iterator es un iterador contiguo, refiriéndose a los elementos que se encuentran contiguos en memoria. (concepto)
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)
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)
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)
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)
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)
Requerimientos comunes de algoritmos
indirectly_swappable (C++20)	Especifica que los valores referenciados por dos tipos indirectly_readable pueden intercambiarse (concepto)
indirectly_comparable (C++20)	Especifica que los valores referenciados por dos tipos indirectly_readable pueden compararse (concepto)
permutable (C++20)	Especifica los requerimientos comunes de los algoritmos que reordenan elementos en su lugar (concepto)
mergeable (C++20)	Especifica los requerimientos de los algoritmos que fusionan secuencias ordenadas en una secuencia de salida copiando elementos (concepto)
sortable (C++20)	Especifica los requerimientos comunes de los algoritmos que permutan secuencias en secuencias ordenadas (concepto)
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)
projected (C++20)	Plantilla asistente para especificar las restricciones de algoritmos que aceptan proyecciones (plantilla de clase)
Tipos asociados
incrementable_traits	Calcula el tipo diferencia de un tipo weakly_incrementable. (plantilla de clase)
indirectly_readable_traits	Calcula el tipo del valor de un tipo indirectly_readable. (plantilla de clase)
iter_value_titer_reference_titer_difference_titer_rvalue_reference_titer_common_reference_t	Calcula los tipos asociados de un iterador. (plantilla de alias)
Primitivas
iterator_traits	Proporciona una interfaz uniforme para las propiedades de un iterador. (plantilla de clase)
input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tag	Tipos clase vacíos para indicar categorías de iteradores. (clase)
iterator	El iterador básico. (plantilla de clase)
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 una referencia rvalue. (plantilla de clase)
move_sentinel (C++20)	Adaptador de centinela para uso con std::move_iterator (plantilla de clase)
common_iterator (C++20)	Adapta un tipo de iterador y su centinela a un tipo de iterador común. (plantilla de clase)
default_sentinel_t (C++20)	Centinela por defecto para uso 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 se compara desigual a cualquier tipo [[cpp//WeaklyIncrementable|WeaklyIncrementable]]. (clase)
back_insert_iterator	Adaptador de iterador para la inserción al final de un contenedor. (plantilla de clase)
front_insert_iterator	Adaptador de iterador para la inserción en la parte frontal de un contenedor. (plantilla de clase)
insert_iterator	Adaptador de iterador para la inserción en un contenedor. (plantilla de clase)
Iteradores de flujos
istream_iterator	Iterador de entrada que lee de un flujo de entrada (std::basic_istream). (plantilla de clase)
ostream_iterator	Iterador de salida que escribe a un flujo de salida (std::basic_ostream). (plantilla de clase)
istreambuf_iterator	Iterador de entrada que lee de un búfer de flujo (std::basic_streambuf). (plantilla de clase)
ostreambuf_iterator	Iterador de salida que escribe a un búfer de flujo (std::basic_streambuf). (plantilla de clase)
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)
iter_swap (C++20)	Intercambia los valores referenciados por dos objetos desreferenciables. (objeto punto de personalización)
Funciones
Adaptors
make_reverse_iterator (C++14)	Crea un std::reverse_iterator del tipo inferido a partir del argumento. (plantilla de función)
make_move_iterator (C++11)	Crea un std::move_iterator del tipo inferido a partir del argumento. (plantilla de función)
front_inserter	Crea un std::front_insert_iterator de tipo inferido a partir del argumento. (plantilla de función)
back_inserter	Crea un std::back_insert_iterator de tipo inferido a partir del argumento. (plantilla de función)
inserter	Crea un std::insert_iterator de tipo inferido a partir del argumento. (plantilla de función)
Operadores no miembro
operator==operator!=operator<operator<=operator>operator>=	compara los iteradores subyacentes (plantilla de función)
operator+	avanza el iterador Original: advances the iterator The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (plantilla de función)
operator-	calcula la distancia entre dos adaptadores iterador Original: computes the distance between two iterator adaptors The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (plantilla de función)
operator==operator!=operator<operator<=operator>operator>=	compara los iteradores subyacentes (plantilla de función)
operator+	avanza el iterador Original: advances the iterator The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (plantilla de función)
operator-	calcula la distancia entre dos adaptadores iterador Original: computes the distance between two iterator adaptors The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (plantilla de función)
operator==operator!=	compara dos istream_iterator (plantilla de función)
operator==operator!=	compara dos istreambuf_iterator (plantilla de función)
Operaciones
advance	Avanza un iterador en una distancia determinada. (función)
distance	Devuelve la distancia entre dos iteradores. (función)
next (C++11)	Incrementa un iterador. (función)
prev (C++11)	Decrementa un iterador. (función)
ranges::advance (C++20)	Avanza un iterador en una distancia dada o a un límite dado. (niebloid)
ranges::distance (C++20)	Devuelve la distancia entre un iterador y un centinela, o entre el principio y el fin de un rango. (niebloid)
ranges::next (C++20)	Incrementa un iterador en una distancia dada o a un límite. (niebloid)
ranges::prev (C++20)	Decrementa un iterador en una distancia dada o a un límite. (niebloid)
Acceso a rangos
begincbegin (C++11)(C++14)	Devuelve un iterator al comienzo de un contenedor o array. (plantilla de función)
endcend (C++11)(C++14)	Devuelve un iterator al final de un contenedor o array (plantilla de función)
rbegincrbegin (C++14)	Devuelve un iterador inverso al contenedor o array (plantilla de función)
rendcrend (C++14)	Devuelve un iterador inverso al final para un contenedor o array (plantilla de función)
sizessize (C++17)(C++20)	Devuelve el tamaño de un contenedor o un array. (plantilla de función)
empty (C++17)	Comprueba si un contenedor está vacío (plantilla de función)
data (C++17)	Obtiene el puntero al array subyacente. (plantilla de función)

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

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

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

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

Concepto incrementable

namespace std {
  template<class I>
    concept incrementable =
      regular<I> &&
      weakly_incrementable<I> &&
      requires(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>;
}

Concepto sentinel_for

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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>
    concept indirectly_copyable =
      indirectly_readable<In> &&
      indirectly_writable<Out, iter_reference_t<In>>;
}

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

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

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

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

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

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

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

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  = /* 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;
  };
}

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

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

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

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

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 exposición
    T value;                                 // solo 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 exposición
    const CharT* delim = nullptr;                                // solo 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           = /* 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_; }
  };
}

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

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