std::ranges::views::single, std::ranges::single_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

 

<tbody> </tbody>

Definido en el archivo de encabezado <ranges>
template< std::copy_constructible T > requires std::is_object_v<T> class single_view : public ranges::view_interface<single_view<T>>	(1)	(desde C++20)
namespace views { inline constexpr /*no especificado*/ single = /*no especificado*/; }	(2)	(desde C++20)
Signatura de la llamada
template< class T > requires /* véase a continuación */ constexpr /*véase a continuación*/ single( T&& t );		(desde C++20)

1) Produce una vista (view) que contiene exactamente un elemento de un valor especificado.

2) La expresión views::single(e) es equivalente en expresión a single_view<std::decay_t<decltype((e))>>(e) para cualquier subexpresión e adecuada.

See More

Las implementaciones habituales de single_view almacenan un solo miembro de tipo copyable-box<T>. Para efectos de descripción, este miembro se denominará en lo sucesivo value_.

El tiempo de vida del elemento está vinculado a la vista (single_view) padre. Copiar single_view hace una copia del elemento.

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::single_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 single_view_ftor). Todos los ejemplares de single_view_ftor son iguales. Por lo tanto, views::single_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::single_view mencionado anteriormente, single_view_ftor satisfará a std::invocable<const single_view_ftor&, Args...>. De lo contrario, ningún operador de llamada a función de single_view_ftor participa en la resolución de sobrecarga.

Funciones miembro

(constructor) (C++20)	Construye un objeto single_view. (función miembro pública)
begin (C++20)	Devuelve un puntero al elemento. (función miembro pública)
end (C++20)	Devuelve un puntero después del elemento. (función miembro pública)
size [estático] (C++20)	Devuelve 1 (uno). (función miembro estática pública)
data (C++20)	Devuelve un puntero al elemento. (función miembro pública)
Heredadas de ranges::view_interface
empty (C++20)	Devuelve si la vista derivada está vacía o no. Se proporciona si la vista derivada satisface forward_range. (función miembro pública de std::ranges::view_interface<D>)
operator bool (C++20)	Devuelve si la vista derivada está vacía o no. Se proporciona si ranges::empty le es aplicable. (función miembro pública de std::ranges::view_interface<D>)
front (C++20)	Devuelve el primer elemento en la vista derivada. Se proporciona si la vista derivada satisface forward_range. (función miembro pública de std::ranges::view_interface<D>)
back (C++20)	Devuelve el último elemento en una vista derivada. Se proporciona si la vista derivada satisface bidirectional_range y common_range. (función miembro pública de std::ranges::view_interface<D>)
operator[] (C++20)	Devuelve el enésimo elemento en la vista derivada. Se proporciona si la vista derivada satisface random_access_range. (función miembro pública de std::ranges::view_interface<D>)

std::ranges::single_view::single_view

<tbody> </tbody>

single_view() requires std::default_initializable<T> = default;	(1)	(desde C++20)
constexpr explicit single_view( const T& t );	(2)	(desde C++20)
constexpr explicit single_view( T&& t );	(3)	(desde C++20)
template< class... Args > requires std::constructible_from<T, Args...> constexpr explicit single_view( std::in_place_t, Args&&... args );	(4)	(desde C++20)

Construye un objeto single_view.

1) Inicializa value_ por defecto, lo que inicializa por valor su valor contenido.

2) Inicializa value_ con t.

3) Inicializa value_ con std::move(t).

4) Inicializa value_ como si fuera por value_{std::in_place, std::forward<Args>(args)...}.

std::ranges::single_view::begin

<tbody> </tbody>

constexpr T* begin() noexcept; constexpr const T* begin() const noexcept;		(desde C++20)

Equivalente a return data();.

std::ranges::single_view::end

<tbody> </tbody>

constexpr T* end() noexcept; constexpr const T* end() const noexcept;		(desde C++20)

Equivalente a return data() + 1;.

std::ranges::single_view::size

<tbody> </tbody>

static constexpr std::size_t size() noexcept;		(desde C++20)

Equivalente a return 1;.

Esta es una función estática. Esto hace que single_view modele /*tiny-range*/ como se requiere por split_view.

std::ranges::single_view::data

<tbody> </tbody>

constexpr T* data() noexcept; constexpr const T* data() const noexcept;		(desde C++20)

Devuelve un puntero al valor contenido de value_. El comportamiento no está definido si value_ no contiene un valor.

Guías de deducción

<tbody> </tbody>

template<class T> single_view(T) -> single_view<T>;		(desde C++20)

Notas

Para single_view, la función miembro heredada empty siempre devuelve false, y la función de conversión heredada operator bool siempre devuelve true.

Ejemplo

Ejecuta este código

#include <iostream>
#include <iomanip>
#include <ranges>
#include <string>
#include <tuple>

int main()
{
    constexpr std::ranges::single_view sv1{3.1415}; // usa constructor (const T&)
    static_assert(sv1);
    static_assert(not sv1.empty());

    std::cout << "1) *sv1.data(): " << *sv1.data() << '\n'
              << "2) *sv1.begin(): " << *sv1.begin() << '\n'
              << "3)  sv1.size(): " << sv1.size() << '\n'
              << "4)  distance: " << std::distance(sv1.begin(), sv1.end()) << '\n';

    std::string str{"C++20"};
    std::cout << "5)  str = " << std::quoted(str) << '\n';
    std::ranges::single_view sv2{std::move(str)}; // usa constructor (T&&)
    std::cout << "6) *sv2.data(): " << quoted(*sv2.data()) << '\n'
              << "7)  str = " << quoted(str) << '\n';

    std::ranges::single_view<std::tuple<int, double, std::string>>
        sv3{std::in_place, 42, 3.14, "😄"}; // usa (std::in_place_t, Args&&... args)

    std::cout << "8)  sv3 alberga una tupla: { "
              << std::get<0>(sv3[0]) << ", "
              << std::get<1>(sv3[0]) << ", "
              << std::get<2>(sv3[0]) << " }\n";
}

Salida:

1) *sv1.data(): 3.1415
2) *sv1.begin(): 3.1415
3)  sv1.size(): 1
4)  distance: 1
5)  str = "C++20"
6) *sv2.data(): "C++20"
7)  str = ""
8)  sv3 alberga una tupla: { 42, 3.14, 😄 }

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
LWG 3428	C++20	single_view era convertible a partir de std::in_place_t.	El constructor se hizo explícito.
P2367R0	C++20	Las guías de deducción para single_view no conseguían que el argumento decayera; views::single copiaba pero no envolvía un objeto single_view.	Se proporcionó una guía para hacer decaer el argumento; se hizo que siempre envolviera.

Véase también

ranges::empty_viewviews::empty (C++20)	Una vista (view) sin elementos. (plantilla de clase) (plantilla de variables)
ranges::split_viewviews::split (C++20)	Una vista (view) sobre los subrangos obtenidos al dividir otra vista usando un delimitador. (plantilla de clase) (objeto adaptador de rango)