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)

 

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óntemplate<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 incrementablestemplate<class>struct incrementable_traits;template<class T>using iter_difference_t =/* véase descripción */;   // rasgos indirectamente legiblestemplate<class>struct indirectly_readable_traits;template<class T>using iter_value_t =/* véase descripción */;   // rasgos de iteradortemplate<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óninlinenamespace/* sin especificar */{// ranges​::​iter_moveinlineconstexpr/* sin especificar */ iter_move =/* sin especificar */;   // ranges​::​iter_swapinlineconstexpr/* 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_readabletemplate<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_writabletemplate<class Out, class T> concept indirectly_writable =/* véase descripción */;   // concepto weakly_incrementabletemplate<class I> concept weakly_incrementable =/* véase descripción */;   // concepto incrementabletemplate<class I> concept incrementable =/* véase descripción */;   // concepto input_or_output_iteratortemplate<class I> concept input_or_output_iterator =/* véase descripción */;   // concepto sentinel_fortemplate<class S, class I> concept sentinel_for =/* véase descripción */;   // concepto sized_sentinel_fortemplate<class S, class I>inlineconstexprbool disable_sized_sentinel =false;   template<class S, class I> concept sized_sentinel_for =/* véase descripción */;   // concepto input_iteratortemplate<class I> concept input_iterator =/* véase descripción */;   // concepto output_iteratortemplate<class I, class T> concept output_iterator =/* véase descripción */;   // concepto forward_iteratortemplate<class I> concept forward_iterator =/* véase descripción */;   // concepto bidirectional_iteratortemplate<class I> concept bidirectional_iterator =/* véase descripción */;   // concepto random_access_iteratortemplate<class I> concept random_access_iterator =/* véase descripción */;   // concepto contiguous_iteratortemplate<class I> concept contiguous_iterator =/* véase descripción */;   // requerimientos de invocable indirecto// invocables indirectostemplate<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>...>;   // proyectadotemplate<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>structprojected;   template<weakly_incrementable I, class Proj>struct incrementable_traits<projected<I, Proj>>;   // requerimientos comunes de algoritmos// concepto indirectly_movabletemplate<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_copyabletemplate<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_swappabletemplate<class I1, class I2 = I1> concept indirectly_swappable =/* véase descripción */;   // concepto indirectly_comparabletemplate<class I1, class I2, class R, class P1 = identity, class P2 = identity> concept indirectly_comparable =/* véase descripción */;   // concepto permutabletemplate<class I> concept permutable =/* véase descripción */;   // concepto mergeabletemplate<class I1, class I2, class Out, class R =ranges::less, class P1 = identity, class P2 = identity> concept mergeable =/* véase descripción */;   // concepto sortabletemplate<class I, class R =ranges::less, class P = identity> concept sortable =/* véase descripción */;   // primitivas// etiquetas de iteradorstruct 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 iteradortemplate<class InputIter, class Distance>constexprvoid advance(InputIter& i, Distance n);template<class InputIter>constexprtypename 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 rangonamespace ranges {// ranges​::​advancetemplate<input_or_output_iterator I>constexprvoid advance(I& i, iter_difference_t<I> n);template<input_or_output_iterator I, sentinel_for<I> S>constexprvoid 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​::​distancetemplate<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​::​nexttemplate<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​::​prevtemplate<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 inversostemplate<class Iter>class reverse_iterator;   template<class Iter1, class Iter2>constexprbool operator==(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);template<class Iter1, class Iter2>constexprbool operator!=(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);template<class Iter1, class Iter2>constexprbool operator<(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);template<class Iter1, class Iter2>constexprbool operator>(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);template<class Iter1, class Iter2>constexprbool operator<=(const reverse_iterator<Iter1>& x, const reverse_iterator<Iter2>& y);template<class Iter1, class Iter2>constexprbool 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>constexprauto 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>)inlineconstexprbool disable_sized_sentinel<reverse_iterator<Iter1>, reverse_iterator<Iter2>>=true;   // iteradores de insercióntemplate<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 movimientotemplate<class Iter>class move_iterator;   template<class Iter1, class Iter2>constexprbool operator==(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);template<class Iter1, class Iter2>constexprbool operator<(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);template<class Iter1, class Iter2>constexprbool operator>(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);template<class Iter1, class Iter2>constexprbool operator<=(const move_iterator<Iter1>& x, const move_iterator<Iter2>& y);template<class Iter1, class Iter2>constexprbool 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>constexprauto 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 comunestemplate<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 defectostruct default_sentinel_t;inlineconstexpr default_sentinel_t default_sentinel{};   // iteradores contadostemplate<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 inalcanzablesstruct unreachable_sentinel_t;inlineconstexpr unreachable_sentinel_t unreachable_sentinel{};   // iteradores de flujotemplate<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 rangostemplate<class C>constexprauto begin(C& c)-> decltype(c.begin());template<class C>constexprauto begin(const C& c)-> decltype(c.begin());template<class C>constexprauto end(C& c)-> decltype(c.end());template<class C>constexprauto 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>constexprauto cbegin(const C& c)noexcept(noexcept(std::begin(c)))-> decltype(std::begin(c));template<class C>constexprauto cend(const C& c)noexcept(noexcept(std::end(c)))-> decltype(std::end(c));template<class C>constexprauto rbegin(C& c)-> decltype(c.rbegin());template<class C>constexprauto rbegin(const C& c)-> decltype(c.rbegin());template<class C>constexprauto rend(C& c)-> decltype(c.rend());template<class C>constexprauto 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>constexprauto crbegin(const C& c)-> decltype(std::rbegin(c));template<class C>constexprauto crend(const C& c)-> decltype(std::rend(c));   template<class C>constexprauto 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>constexprauto 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]]constexprauto empty(const C& c)-> decltype(c.empty());template<class T, size_t N>[[nodiscard]]constexprbool empty(const T (&a)[N])noexcept;template<class E>[[nodiscard]]constexprbool empty(initializer_list<E> il)noexcept;template<class C>constexprauto data(C& c)-> decltype(c.data());template<class C>constexprauto data(const C& c)-> decltype(c.data());template<class T, size_t N>constexpr T* data(T (&a)[N])noexcept;template<class E>constexprconst 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 igualdadconst_cast<const iter_reference_t<Out>&&>(*o)=std::forward<T>(t);// no se requiere que conserve la igualdadconst_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>inlineconstexprbool __is_integer_like =/* véase descripción */;// solo exposición   template<class T>inlineconstexprbool __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óntemplate<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>structprojected{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();constexprexplicit 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;   friendconstexpr iter_rvalue_reference_t<Iter> iter_move(const reverse_iterator& i)noexcept(/* véase descripción */);template<indirectly_swappable<Iter> Iter2>friendconstexprvoid 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;constexprexplicit back_insert_iterator(Container& x);constexpr back_insert_iterator& operator=(consttypename 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;constexprexplicit front_insert_iterator(Container& x);constexpr front_insert_iterator& operator=(consttypename 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=(consttypename 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();constexprexplicit 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++();constexprauto 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>friendconstexprbool operator==(const move_iterator& x, const move_sentinel<S>& y);template<sized_sentinel_for<Iter> S>friendconstexpr iter_difference_t<Iter> operator-(const move_sentinel<S>& x, const move_iterator& y);template<sized_sentinel_for<Iter> S>friendconstexpr iter_difference_t<Iter> operator-(const move_iterator& x, const move_sentinel<S>& y);friendconstexpr iter_rvalue_reference_t<Iter> iter_move(const move_iterator& i)noexcept(noexcept(ranges::iter_move(i.current)));template<indirectly_swappable<Iter> Iter2>friendconstexprvoid 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();constexprexplicit 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>friendbool 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>friendbool 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>friendvoid 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()constnoexcept;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>;friendconstexpr 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>friendconstexpr iter_difference_t<I2> operator-(const counted_iterator& x, const counted_iterator<I2>& y);friendconstexpr iter_difference_t<I> operator-(const counted_iterator& x, default_sentinel_t);friendconstexpr 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>friendconstexprbool operator==(const counted_iterator& x, const counted_iterator<I2>& y);friendconstexprbool operator==(const counted_iterator& x, default_sentinel_t);   template<common_with<I> I2>friendconstexpr strong_ordering operator<=>(const counted_iterator& x, const counted_iterator<I2>& y);   friendconstexpr 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>friendconstexprvoid 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>friendconstexprbool operator==(unreachable_sentinel_t, const I&)noexcept{returnfalse;}};}

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);   friendbool 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ónconst 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;   friendbool 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()constnoexcept;   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;};}