Experimental library header <experimental/ranges/iterator>

From cppreference.net

<experimental/execution>

Filesystem TS

<experimental/filesystem>

Parallelism TS (v1, v2)

`experimental/algorithm`
`experimental/execution_policy`
`experimental/exception_list`

`experimental/numeric`
`<experimental/simd>`
`experimental/task_block`

Library Fundamentals TS (v1, v2, v3)

`experimental/algorithm`
`<experimental/any>`
`experimental/array`
`experimental/chrono`
`experimental/deque`
`experimental/forward_list`
`<experimental/functional>`
`experimental/future`
`experimental/iterator`
`experimental/list`
`experimental/map`
`experimental/memory`
`<experimental/memory_resource>`
`experimental/numeric`
`<experimental/optional>`
`experimental/propagate_const`

`experimental/random`
`experimental/ratio`
`experimental/regex`
`experimental/scope`
`experimental/set`
`experimental/source_location`
`experimental/string`
`<experimental/string_view>`
`experimental/system_error`
`experimental/tuple`
`experimental/type_traits`
`experimental/unordered_map`
`experimental/unordered_set`
`experimental/utility`
`experimental/vector`

Concurrency TS

`experimental/atomic`
`experimental/barrier`

`experimental/future`
`experimental/latch`

Ranges TS

`<experimental/ranges/algorithm>`
`<experimental/ranges/concepts>`
`<experimental/ranges/functional>`
`<experimental/ranges/iterator>`

`<experimental/ranges/random>`
`<experimental/ranges/tuple>`
`<experimental/ranges/type_traits>`
`<experimental/ranges/utility>`

Coroutines TS


               experimental/coroutine

Networking TS

`experimental/buffer`
`experimental/executor`
`experimental/internet`
`experimental/io_context`

`<experimental/net>`
`experimental/netfwd`
`experimental/socket`
`experimental/timer`

Reflection TS

<experimental/reflect>

Este encabezado es parte de la biblioteca ranges .

Contenidos

Conceptos relacionados con iteradores

Definido en el espacio de nombres


           std::experimental::ranges

Conceptos de iterador

Readable	especifica que un tipo es legible aplicando el operador `*` (concept)
Writable	especifica que un valor puede escribirse en el objeto referenciado por un iterador (concept)
WeaklyIncrementable	especifica que un tipo `Semiregular` puede incrementarse con operadores de preincremento y postincremento (concept)
Incrementable	especifica que la operación de incremento en un tipo `WeaklyIncrementable` preserva la igualdad y que el tipo es `EqualityComparable` (concept)
Iterator	especifica que los objetos de un tipo pueden incrementarse y desreferenciarse (concept)
Sentinel	especifica que los objetos de un tipo son un centinela para un tipo `Iterator` (concept)
SizedSentinel	especifica que el operador `-` puede aplicarse a un iterador y un centinela para calcular su diferencia en tiempo constante (concept)
InputIterator	especifica que un tipo es un iterador de entrada, es decir, sus valores referenciados pueden leerse y puede preincrementarse y postincrementarse (concept)
OutputIterator	especifica que un tipo es un iterador de salida para un tipo de valor dado, es decir, pueden escribirse valores de ese tipo en él y puede preincrementarse y postincrementarse (concept)
ForwardIterator	especifica que un `InputIterator` es un iterador de avance, que admite comparación de igualdad y múltiples pasadas (concept)
BidirectionalIterator	especifica que un `ForwardIterator` es un iterador bidireccional, que admite movimiento hacia atrás (concept)
RandomAccessIterator	especifica que un `BidirectionalIterator` es un iterador de acceso aleatorio, que admite avance en tiempo constante e indexación (concept)

Conceptos de invocables indirectos

IndirectUnaryInvocable IndirectRegularUnaryInvocable	especifica que un tipo invocable puede ser invocado con el resultado de desreferenciar un `Readable` type (concepto)
IndirectUnaryPredicate	especifica que un objeto invocable, cuando se invoca con el resultado de desreferenciar un `Readable` type, satisface `Predicate` (concepto)
IndirectRelation	especifica que un objeto invocable, cuando se invoca con el resultado de desreferenciar algunos `Readable` types, satisface `Relation` (concepto)
IndirectStrictWeakOrder	especifica que un objeto invocable, cuando se invoca con el resultado de desreferenciar algunos `Readable` types, satisface `StrictWeakOrder` (concepto)

Requisitos comunes de algoritmos

IndirectlyMovable	especifica que los valores pueden ser movidos desde un tipo `Readable` a un tipo `Writable` (concepto)
IndirectlyMovableStorable	especifica que los valores pueden ser movidos desde un tipo `Readable` a un tipo `Writable` y que el movimiento puede realizarse mediante un objeto intermedio (concepto)
IndirectlyCopyable	especifica que los valores pueden ser copiados desde un tipo `Readable` a un tipo `Writable` (concepto)
IndirectlyCopyableStorable	especifica que los valores pueden ser copiados desde un tipo `Readable` a un tipo `Writable` y que la copia puede realizarse mediante un objeto intermedio (concepto)
IndirectlySwappable	especifica que los valores referenciados por dos tipos `Readable` pueden ser intercambiados (concepto)
IndirectlyComparable	especifica que los valores referenciados por dos tipos `Readable` pueden ser comparados (concepto)
Permutable	especifica los requisitos comunes de los algoritmos que reordenan elementos in situ (concepto)
Mergeable	especifica los requisitos de los algoritmos que fusionan secuencias ordenadas en una secuencia de salida copiando elementos (concepto)
Sortable	especifica los requisitos comunes de los algoritmos que permutan secuencias en secuencias ordenadas (concepto)

Utilidades de conceptos

indirect_result_of	calcular el resultado de invocar un objeto invocable sobre el resultado de desreferenciar algunos tipos `Readable` (plantilla de clase)
projected	plantilla auxiliar para especificar las restricciones en algoritmos que aceptan proyecciones (plantilla de clase)

Primitivas de iterador

Utilidades de iteradores

Definido en el espacio de nombres `std::experimental::ranges`
iter_move	convierte el resultado de desreferenciar un objeto a su tipo de referencia de valor asociado (objeto de punto de personalización)
iter_swap	intercambia los valores referenciados por dos objetos desreferenciables (objeto de punto de personalización)

Rasgos del iterador

Definido en el espacio de nombres `std::experimental::ranges`
difference_type	obtiene el tipo de diferencia de un tipo `WeaklyIncrementable` (plantilla de clase)
value_type	obtiene el tipo de valor de un tipo `Readable` (plantilla de clase)
iterator_category	obtiene la categoría de iterador de un tipo de iterador de entrada (plantilla de clase)
iterator_traits	clase de rasgos de compatibilidad que recopila los tipos asociados de un iterador (plantilla de alias)
reference_t rvalue_reference_t iter_common_reference_t	obtiene los tipos de referencia asociados de un objeto desreferenciable (plantilla de alias)

Etiquetas de categoría de iterador

Definido en el espacio de nombres `std::experimental::ranges`
input_iterator_tag output_iterator_tag forward_iterator_tag bidirectional_iterator_tag random_access_iterator_tag	tipos de clases vacías utilizados para indicar categorías de iteradores (clase)

std::iterator_traits especializaciones

Definido en el espacio de nombres `std`
std::iterator_traits <InputIterator> std::iterator_traits <OutputIterator>	especializa std::iterator_traits para iteradores de ranges TS (especialización de plantilla de clase)

Operaciones de iterador

Definido en el espacio de nombres `std::experimental::ranges`
advance	avanza un iterador una distancia dada (plantilla de función)
distance	retorna la distancia entre un iterador y un centinela, o entre el inicio y el final de un rango (plantilla de función)
next	incrementa un iterador (plantilla de función)
prev	decrementa un iterador (plantilla de función)

Adaptadores de iteradores

Definido en el espacio de nombres `std::experimental::ranges`
reverse_iterator	adaptador de iterador para recorrido en orden inverso (plantilla de clase)
back_insert_iterator	adaptador de iterador para inserción al final de un contenedor (plantilla de clase)
front_insert_iterator	adaptador de iterador para inserción al frente de un contenedor (plantilla de clase)
insert_iterator	adaptador de iterador para inserción en un contenedor (plantilla de clase)
move_iterator	adaptador de iterador que se desreferencia a una referencia de valor R (plantilla de clase)
move_sentinel	adaptador de centinela para usar con `move_iterator` (plantilla de clase)
common_iterator	adapta un par iterador-centinela a un tipo de iterador común para usar con algoritmos heredados (plantilla de clase)
counted_iterator	adaptador de iterador que mantiene registro de su distancia desde su posición inicial (plantilla de clase)
default_sentinel	tipo de centinela vacío para usar con tipos de iterador que conocen el límite de su rango (clase)
dangling	envoltorio para un iterador potencialmente colgante (plantilla de clase)
safe_iterator_t	plantilla de alias que envuelve el tipo de iterador de un rango de valor R con `dangling` (plantilla de alias)
unreachable	tipo de centinela usado con cualquier iterador para denotar un rango infinito (clase)

Iteradores de flujo

Definido en el espacio de nombres `std::experimental::ranges`
istream_iterator	iterador de entrada que lee desde std::basic_istream (plantilla de clase)
ostream_iterator	iterador de salida que escribe en std::basic_ostream (plantilla de clase)
istreambuf_iterator	iterador de entrada que lee desde std::basic_streambuf (plantilla de clase)
ostreambuf_iterator	iterador de salida que escribe en std::basic_streambuf (plantilla de clase)

Sinopsis

namespace std { namespace experimental { namespace ranges { inline namespace v1 {
template <class T> concept bool /* dereferenceable */ // exposición solamente
  = requires(T& t) { {*t} -> auto&&; };
namespace {
  constexpr /* sin especificar */ iter_move = /* sin especificar */;
  constexpr /* sin especificar */ iter_swap = /* sin especificar */;
}
template <class> struct difference_type;
template <class T> using difference_type_t
  = typename difference_type<T>::type;
template <class> struct value_type;
template <class T> using value_type_t
  = typename value_type<T>::type;
template <class> struct iterator_category;
template <class T> using iterator_category_t
  = typename iterator_category<T>::type;
template </* dereferenceable */ T> using reference_t
  = decltype(*declval<T&>());
template </* dereferenceable */ T>
    requires /* ver definición */ using rvalue_reference_t
  = decltype(ranges::iter_move(declval<T&>()));
template <class In>
concept bool Readable = /* ver definición */;
template <class Out, class T>
concept bool Writable = /* ver definición */;
template <class I>
concept bool WeaklyIncrementable = /* ver definición */;
template <class I>
concept bool Incrementable = /* ver definición */;
template <class I>
concept bool Iterator = /* ver definición */;
template <class S, class I>
concept bool Sentinel = /* ver definición */;
template <class S, class I>
  constexpr bool disable_sized_sentinel = false;
template <class S, class I>
concept bool SizedSentinel = /* ver definición */;
template <class I>
concept bool InputIterator = /* ver definición */;
template <class I>
concept bool OutputIterator = /* ver definición */;
template <class I>
concept bool ForwardIterator = /* ver definición */;
template <class I>
concept bool BidirectionalIterator = /* ver definición */;
template <class I>
concept bool RandomAccessIterator = /* ver definición */;
template <class F, class I>
concept bool IndirectUnaryInvocable = /* ver definición */;
template <class F, class I>
concept bool IndirectRegularUnaryInvocable = /* ver definición */;
template <class F, class I>
concept bool IndirectUnaryPredicate = /* ver definición */;
template <class F, class I1, class I2 = I1>
concept bool IndirectRelation = /* ver definición */;
template <class F, class I1, class I2 = I1>
concept bool IndirectStrictWeakOrder = /* ver definición */;
template <class> struct indirect_result_of;
template <class F, class... Es>
  requires Invocable<F, reference_t<Is>...>
struct indirect_result_of<F(Is...)>;
template <class F>
using indirect_result_of_t
  = typename indirect_result_of<F>::type;
template <Readable I, IndirectRegularUnaryInvocable<I> Proj>
struct projected;
template <WeaklyIncrementable I, class Proj>
struct difference_type<projected<I, Proj>>;
template <class In, class Out>
concept bool IndirectlyMovable = /* ver definición */;
template <class In, class Out>
concept bool IndirectlyMovableStorable = /* ver definición */;
template <class In, class Out>
concept bool IndirectlyCopyable = /* ver definición */;
template <class In, class Out>
concept bool IndirectlyCopyableStorable = /* ver definición */;
template <class I1, class I2 = I1>
concept bool IndirectlySwappable = /* ver definición */;
template <class I1, class I2, class R = equal_to<>, class P1 = identity,
    class P2 = identity>
concept bool IndirectlyComparable = /* ver definición */;
template <class I>
concept bool Permutable = /* ver definición */;
template <class I1, class I2, class Out,
    class R = less<>, class P1 = identity, class P2 = identity>
concept bool Mergeable = /* ver definición */;
template <class I, class R = less<>, class P = identity>
concept bool Sortable = /* ver definición */;
template <class Iterator> using iterator_traits = /* ver definición */;
template <Readable T> using iter_common_reference_t
  = common_reference_t<reference_t<T>, value_type_t<T>&>;
struct output_iterator_tag { };
struct input_iterator_tag { };
struct forward_iterator_tag : input_iterator_tag { };
struct bidirectional_iterator_tag : forward_iterator_tag { };
struct random_access_iterator_tag : bidirectional_iterator_tag { };
namespace {
  constexpr /* sin especificar */ advance = /* sin especificar */;
  constexpr /* sin especificar */ distance = /* sin especificar */;
  constexpr /* sin especificar */ next = /* sin especificar */;
  constexpr /* sin especificar */ prev = /* sin especificar */;
}
template <BidirectionalIterator I> class reverse_iterator;
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator==(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator!=(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>=(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<=(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <class I1, class I2>
    requires SizedSentinel<I1, I2>
  constexpr difference_type_t<I2> operator-(
    const reverse_iterator<I1>& x,
    const reverse_iterator<I2>& y);
template <RandomAccessIterator I>
  constexpr reverse_iterator<I> operator+(
    difference_type_t<I> n,
    const reverse_iterator<I>& x);
template <BidirectionalIterator I>
constexpr reverse_iterator<I> make_reverse_iterator(I i);
template <class Container> class back_insert_iterator;
template <class Container>
  back_insert_iterator<Container> back_inserter(Container& x);
template <class Container> class front_insert_iterator;
template <class Container>
  front_insert_iterator<Container> front_inserter(Container& x);
template <class Container> class insert_iterator;
template <class Container>
  insert_iterator<Container> inserter(Container& x, iterator_t<Container> i);
template <InputIterator I> class move_iterator;
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator==(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires EqualityComparableWith<I1, I2>
  constexpr bool operator!=(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator<=(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires StrictTotallyOrderedWith<I1, I2>
  constexpr bool operator>=(
    const move_iterator<I1>& x, const move_iterator<I2>& y);
template <class I1, class I2>
    requires SizedSentinel<I1, I2>
  constexpr difference_type_t<I2> operator-(
    const move_iterator<I1>& x,
    const move_iterator<I2>& y);
template <RandomAccessIterator I>
  constexpr move_iterator<I> operator+(
    difference_type_t<I> n,
    const move_iterator<I>& x);
template <InputIterator I>
  constexpr move_iterator<I> make_move_iterator(I i);
template <Semiregular S> class move_sentinel;
template <class I, Sentinel<I> S>
  constexpr bool operator==(
    const move_iterator<I>& i, const move_sentinel<S>& s);
template <class I, Sentinel<I> S>
  constexpr bool operator==(
    const move_sentinel<S>& s, const move_iterator<I>& i);
template <class I, Sentinel<I> S>
  constexpr bool operator!=(
    const move_iterator<I>& i, const move_sentinel<S>& s);
template <class I, Sentinel<I> S>
  constexpr bool operator!=(
    const move_sentinel<S>& s, const move_iterator<I>& i);
template <class I, SizedSentinel<I> S>
  constexpr difference_type_t<I> operator-(
    const move_sentinel<S>& s, const move_iterator<I>& i);
template <class I, SizedSentinel<I> S>
  constexpr difference_type_t<I> operator-(
    const move_iterator<I>& i, const move_sentinel<S>& s);
template <Semiregular S>
  constexpr move_sentinel<S> make_move_sentinel(S s);
template <Iterator I, Sentinel<I> S>
  requires !Same<I, S>
class common_iterator;
template <Readable I, class S>
struct value_type<common_iterator<I, S>>;
template <InputIterator I, class S>
struct iterator_category<common_iterator<I, S>>;
template <ForwardIterator I, class S>
struct iterator_category<common_iterator<I, S>>;
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
bool operator==(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
  requires EqualityComparableWith<I1, I2>
bool operator==(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
template <class I1, class I2, Sentinel<I2> S1, Sentinel<I1> S2>
bool operator!=(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
template <class I2, SizedSentinel<I2> I1, SizedSentinel<I2> S1, SizedSentinel<I1> S2>
difference_type_t<I2> operator-(
  const common_iterator<I1, S1>& x, const common_iterator<I2, S2>& y);
class default_sentinel;
template <Iterator I> class counted_iterator;
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator==(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
constexpr bool operator==(
  const counted_iterator<auto>& x, default_sentinel);
constexpr bool operator==(
  default_sentinel, const counted_iterator<auto>& x);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator!=(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
constexpr bool operator!=(
  const counted_iterator<auto>& x, default_sentinel y);
constexpr bool operator!=(
  default_sentinel x, const counted_iterator<auto>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator<(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator<=(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator>(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr bool operator>=(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I1, class I2>
    requires Common<I1, I2>
  constexpr difference_type_t<I2> operator-(
    const counted_iterator<I1>& x, const counted_iterator<I2>& y);
template <class I>
  constexpr difference_type_t<I> operator-(
    const counted_iterator<I>& x, default_sentinel y);
template <class I>
  constexpr difference_type_t<I> operator-(
    default_sentinel x, const counted_iterator<I>& y);
template <RandomAccessIterator I>
  constexpr counted_iterator<I>
    operator+(difference_type_t<I> n, const counted_iterator<I>& x);
template <Iterator I>
  constexpr counted_iterator<I> make_counted_iterator(I i, difference_type_t<I> n);
class unreachable;
template <Iterator I>
  constexpr bool operator==(const I&, unreachable) noexcept;
template <Iterator I>
  constexpr bool operator==(unreachable, const I&) noexcept;
template <Iterator I>
  constexpr bool operator!=(const I&, unreachable) noexcept;
template <Iterator I>
  constexpr bool operator!=(unreachable, const I&) noexcept;
template <class T> class dangling;
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, class Traits, class Distance>
  bool operator==(default_sentinel x,
    const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
  bool operator==(const istream_iterator<T, CharT, Traits, Distance>& x,
    default_sentinel y);
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, class Traits, class Distance>
  bool operator!=(default_sentinel x,
    const istream_iterator<T, CharT, Traits, Distance>& y);
template <class T, class CharT, class Traits, class Distance>
  bool operator!=(const istream_iterator<T, CharT, Traits, Distance>& x,
    default_sentinel 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>
  bool operator==(default_sentinel a,
    const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
  bool operator==(const istreambuf_iterator<CharT, Traits>& a,
    default_sentinel b);
template <class CharT, class Traits>
  bool operator!=(const istreambuf_iterator<CharT, Traits>& a,
    const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
  bool operator!=(default_sentinel a,
    const istreambuf_iterator<CharT, Traits>& b);
template <class CharT, class Traits>
  bool operator!=(const istreambuf_iterator<CharT, Traits>& a,
    default_sentinel b);
template <class CharT, class Traits = char_traits<CharT> >
  class ostreambuf_iterator;
}}}}
namespace std {
  template <experimental::ranges::Iterator Out>
    struct iterator_traits<Out>;
  template <experimental::ranges::InputIterator In>
    struct iterator_traits<In>;
  template <experimental::ranges::InputIterator In>
      requires experimental::ranges::Centinela<In, In>
    struct iterator_traits;
}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants