std::ranges::views::single, std::ranges::single_view - cppreference.com

De cppreference.com

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.

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>`) [editar]
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>`) [editar]
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>`) [editar]
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>`) [editar]
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>`) [editar]

std::ranges::single_view::single_view

`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

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

Equivalente a return data();.

std::ranges::single_view::end

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

Equivalente a return data() + 1;.

std::ranges::single_view::size

`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

`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

`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

#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.