std::ranges::views::istream, std::ranges::basic_istream_view, std::ranges::istream_view, std::ranges::wistream_view

 

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

 

Biblioteca de rangos

Acceso a rangos begin cbegin   end cend rbegin crbegin   rend crend size ssize   data cdata empty

Conversiones de rangos std::from_range_t std::from_range (C++23)(C++23)     to (C++23)

Manejo de iteradores pendientes dangling borrowed_iterator_t borrowed_subrange_t

Primitivas de rangos
range_size_trange_difference_trange_value_t elements_of (C++23)	iterator_tconst_iterator_tsentinel_tconst_sentinel_t (C++23)(C++23)	range_reference_trange_const_reference_trange_rvalue_reference_trange_common_reference_t (C++23)

Conceptos de rangos
range borrowed_range    sized_range	common_range view viewable_range	input_range output_range forward_range	bidirectional_range    random_access_range contiguous_range	constant_range (C++23)

Vistas
view_interface	subrange

Fábricas de rangos
empty_viewviews::empty	single_viewviews::single	basic_istream_viewviews::istream	iota_viewviews::iota	repeat_viewviews::repeat (C++23)(C++23)

Adaptadores de rangos
views::all_tviews::all ref_view owning_view as_rvalue_viewviews::as_rvalue (C++23)(C++23)   filter_viewviews::filter transform_viewviews::transform take_viewviews::take take_while_viewviews::take_while concat_viewviews::concat (C++26)(C++26) views::counted	drop_viewviews::drop drop_while_viewviews::drop_while join_viewviews::join join_with_viewviews::join_with (C++23)(C++23)   lazy_split_viewviews::lazy_split split_viewviews::split common_viewviews::common cache_latest_viewviews::cache_latest (C++26)(C++26)	reverse_viewviews::reverse as_const_viewviews::as_const (C++23)(C++23) elements_viewviews::elements keys_viewviews::keys values_viewviews::values enumerate_viewviews::enumerate (C++23)(C++23) zip_viewviews::zip (C++23)(C++23) zip_transform_viewviews::zip_transform (C++23)(C++23)	adjacent_viewviews::adjacent (C++23)(C++23) views::pairwise (C++23) adjacent_transform_viewviews::adjacent_transform (C++23)(C++23) views::pairwise_transform (C++23) chunk_viewviews::chunk (C++23)(C++23) slide_viewviews::slide (C++23)(C++23) chunk_by_viewviews::chunk_by (C++23)(C++23) stride_viewviews::stride (C++23)(C++23) cartesian_product_viewviews::cartesian_product (C++23)(C++23)

Generadores de rangos std::generator (C++23)

Objetos cierre adaptadores de rangos range_adaptor_closure (C++23)

Objetos adaptadores de rangos

Elementos auxiliares
copyable-box movable-box (hasta C++23)  (C++23)	simple-view non-propagating-cache

 

std::ranges::basic_istream_view

Funciones miembro

basic_istream_view::basic_istream_view (C++20)

basic_istream_view::begin (C++20)

basic_istream_view::end (C++20)

Iterador

basic_istream_view::iterator::iterator (C++20)

basic_istream_view::iterator::operator= (C++20)

basic_istream_view::iterator::operator++ (C++20)

basic_istream_view::iterator::operator* (C++20)

operator==(basic_istream_view::iterator) (C++20)

 

<tbody> </tbody>

Definido en el archivo de encabezado <ranges>
template< std::movable Val, class CharT, class Traits = std::char_traits<CharT> > requires std::default_initializable<Val> && /*extraíble-del-flujo*/<Val,CharT,Traits> class basic_istream_view : public ranges::view_interface<basic_istream_view<Val,CharT,Traits>>	(1)	(desde C++20)
Plantillas auxiliares
template< class Val > using istream_view = ranges::basic_istream_view<Val, char>;	(2)	(desde C++20)
template< class Val > using wistream_view = ranges::basic_istream_view<Val, wchar_t>;	(3)	(desde C++20)
Objetos de punto de personalización
template< class T > inline constexpr /*no especificado*/ istream = /*no especificado*/;	(4)	(desde C++20)
Conceptos auxiliares
template< class Val, class CharT, class Traits > concept /*extraíble-del-flujo*/ = requires(std::basic_istream<CharT,Traits>& is, Val& t) { is >> t; };	(5)	(desde C++20)

1) Una fábrica de rangos que genera una secuencia de elementos llamando repetidamente a operator>>.

2-3) Plantillas de alias convenientes para los tipos de carácter char y wchar_t.

4) views::istream<T>(e) es equivalente en expresión a (tiene el mismo efecto que) ranges::basic_istream_view<T, typename U::char_type, typename U::traits_type>(e) para cualquier subexpresión e adecuada, donde U es std::remove_reference_t<decltype(e)>. El programa está mal formado si U no está ni públicamente ni inequivocadamente derivada de std::basic_istream<typename U::char_type, typename U::traits_type>, lo que puede resultar en una falla en la sustitución.

5) El concepto de solo exposición /*extraíble-del-flujo*/<Val,CharT,Traits> se satisface cuando el l-valor de Val puede extraerse del l-valor de std::basic_istream<CharT,Traits>.

See More

El tipo iterador de basic_istream_view es de solo movimiento: no cumple con los requerimientos de Iterator, y por lo tanto no funciona con los algoritmos anteriores a C++20.

Equivalente en expresión

La expresión e es equivalente-en-expresión a la expresión f, si e y f tienen los mismos efectos, ambas potencialmente lanzan o ambas potencialmente no lanzan (es decir, noexcept (e) == noexcept(f)), y ambas son subexpresiones constantes o ambas no son subexpresiones constantes.

Objetos de punto de personalización

El nombre views::basic_istream_view denota un objeto de punto de personalización, que es un objeto función const de un tipo clase literal semiregular (denotado, a efectos de exposición, como basic_istream_view_ftor). Todos los ejemplares de basic_istream_view_ftor son iguales. Por lo tanto, views::basic_istream_view puede copiarse libremente y sus copias pueden usarse indistintamente.

Dado un conjunto de tipos Args..., si std::declval<Args>()... cumple con los requerimientos para los argumentos de views::basic_istream_view mencionado anteriormente, basic_istream_view_ftor satisfará a std::invocable<const basic_istream_view_ftor&, Args...>. De lo contrario, ningún operador de llamada a función de basic_istream_view_ftor participa en la resolución de sobrecarga.

Funciones miembro

(constructor) (C++20)	Construye un objeto basic_istream_view. (función miembro pública)
begin (C++20)	Devuelve un iterador. (función miembro pública)
end (C++20)	Devuelve std::default_sentinel. (función miembro pública)
Heredadas de ranges::view_interface
(Ninguna)	Aunque basic_istream_view se deriva de ranges::view_interface, no puede usar ninguna de las funciones miembro heredadas.

std::ranges::basic_istream_view::basic_istream_view

<tbody> </tbody>

constexpr explicit basic_istream_view( std::basic_istream<CharT, Traits>& stream );		(desde C++20)

Inicializa el puntero almacenado para emitir flujo con std::addressof(stream), e inicializa por valor el valor almacenado de Val.

std::ranges::basic_istream_view::begin

<tbody> </tbody>

constexpr auto begin();		(desde C++20)

Equivalente a *stream_ >> value_; return /*iterador*/{*this};, donde stream_ el puntero almacenado para emitir flujo y value_ es el valor almacenado de Val.

std::ranges::basic_istream_view::end

<tbody> </tbody>

constexpr std::default_sentinel_t end() const noexcept;		(desde C++20)

Equivalente a return std::default_sentinel;.

Clases anidadas

iterator (C++20)

El tipo iterador de basic_istream_view, el nombre es solo de exposición. (clase miembro de solo exposición)

Ejemplo

Ejecuta este código

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <ranges>
#include <sstream>
#include <string>

int main()
{
    auto palabras = std::istringstream{"hoy es el mañana del ayer"};
    for (const auto& s: std::ranges::istream_view<std::string>(palabras)) {
        std::cout << std::quoted(s, '/') << ' ';
    }
    std::cout << '\n';

    auto flotantes = std::istringstream{"1.1  2.2\t3.3\v4.4\f55\n66\r7.7  8.8"};
    std::ranges::copy(
        std::ranges::istream_view<float>(flotantes),
        std::ostream_iterator<float>{std::cout, ", "});
    std::cout << '\n';
}

Salida:

/hoy/ /es/ /el/ /mañana/ /del/ /ayer/
1.1, 2.2, 3.3, 4.4, 55, 66, 7.7, 8.8,

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
P2325R3	C++20	Se proporcionaba el constructor por defecto ya que view debía ser default_initializable	Se eliminó, así como el requerimiento.
LWG 3568	C++20	P2325R3 hizo accidentalmente el valor almacenado inicializado por defecto.	Se restauró a inicialización por valor.
P2432R1	C++20	ranges::istream_view era una función de plantilla y no seguía la convención de nombres.	Se hizo una plantilla de alias; se añadieron los objetos de punto de personalización.

Véase también

istream_iterator

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