std::ranges::views::single, std::ranges::single_view

Definido en el 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) (hasta C++23)
template< std::move_constructible T > requires std::is_object_v<T> class single_view : public ranges::view_interface<single_view<T>>	(1)		(desde C++23)
namespace views { inline constexpr /* unspecified / single = / unspecified */; }	(2)	(desde C++20)
Firma de llamada
template< class T > requires /* see below / constexpr / see below */ single( T&& t );		(desde C++20)

1) Produce una 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 adecuada e.

La vida útil del elemento está vinculada al single_view padre. Copiar single_view realiza una copia del elemento.

Objetos de punto de personalización

El nombre views::single denota un objeto de punto de personalización , que es un objeto función constante de un tipo de clase literal semiregular . Consulte CustomizationPointObject para más detalles.

Miembros de datos

Miembro Descripción

`copyable-box` `<T>`	(hasta C++23)
`movable-box` `<T>`	(desde C++23)

value_

el único elemento de la vista
(objeto miembro solo de exposición*)

Funciones miembro

(constructor)	construye un `single_view` (función miembro pública)
begin	devuelve un puntero al elemento (función miembro pública)
end	devuelve un puntero después del elemento (función miembro pública)
empty [static]	devuelve false (función miembro estática pública)
size [static]	devuelve 1 (función miembro estática pública)
data	devuelve un puntero al elemento (función miembro pública)
Heredado de ranges::view_interface
cbegin (C++23)	devuelve un iterador constante al inicio del rango (función miembro pública de `std::ranges::view_interface<D>`)
cend (C++23)	devuelve un centinela para el iterador constante del rango (función miembro pública de `std::ranges::view_interface<D>`)
operator bool	devuelve si la vista derivada no está vacía, proporcionada solo si ranges::empty le es aplicable (función miembro pública de `std::ranges::view_interface<D>`)
front	devuelve el primer elemento en la vista derivada, proporcionada si satisface `forward_range` (función miembro pública de `std::ranges::view_interface<D>`)
back	devuelve el último elemento en la vista derivada, proporcionada solo si satisface `bidirectional_range` y `common_range` (función miembro pública de `std::ranges::view_interface<D>`)
operator[]	devuelve el `n`^ésimo elemento en la vista derivada, proporcionada solo si satisface `random_access_range` (función miembro pública de `std::ranges::view_interface<D>`)

std::ranges::single_view:: single_view

single_view ( ) requires std:: default_initializable < T > = default ;	(1)	(desde C++20)
	(2)
constexpr explicit single_view ( const T & t ) ;			(desde C++20) (hasta C++23)
constexpr explicit single_view ( const T & t ) requires std:: copy_constructible < T > ;			(desde C++23)
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 single_view .

1) Inicializa por defecto



          value_

, lo cual inicializa por valor su contenido.

2) Inicializa



          value_

con t .

3) Inicializa



          value_

con std :: move ( t ) .

4) Inicializa



          value_

como si fuera



           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:: empty

static constexpr bool empty ( ) noexcept ;		(desde C++20)

Equivalente a return false ; .

std::ranges::single_view:: size

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

Equivalente a return 1 ; .

Hace que single_view modele /*tiny-range*/ como lo requiere 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 en value_ . El comportamiento es indefinido 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 un 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

Ejecutar este código

#include <iomanip>
#include <iostream>
#include <ranges>
#include <string>
#include <tuple>
int main()
{
    constexpr std::ranges::single_view sv1{3.1415}; // usa el 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 el constructor (T&&)
    std::cout << "6) *sv2.data(): " << std::quoted(*sv2.data()) << '\n'
              << "7)  str = " << std::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 holds a tuple: { "
              << 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 holds a tuple: { 42, 3.14, 😄 }

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR	Aplicado a	Comportamiento publicado	Comportamiento correcto
LWG 3428	C++20	`single_view` era convertible desde std::in_place_t	el constructor se hace explícito
LWG 4035	C++20	`single_view` no proporcionaba la función miembro `empty()`	proporciona `empty()`
P2367R0	C++20	las guías de deducción para `single_view` no aplicaban decay al argumento; `views::single` copiaba pero no envolvía un `single_view`	se proporciona una guía con decay; se hace envolvente siempre

Véase también

optional (C++17)	un contenedor que puede o no contener un objeto (plantilla de clase)
ranges::empty_view views::empty (C++20)	una `view` vacía sin elementos (plantilla de clase) (plantilla de variable)
ranges::split_view views::split (C++20)	una `view` sobre los subrangos obtenidos al dividir otra `view` usando un delimitador (plantilla de clase) (objeto adaptador de rango)

Soporte de compiladores
Independiente y alojado
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos nombrados
Macros de prueba de características (C++20)
Biblioteca de soporte del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnóstico
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de utilidades 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 soporte de concurrencia (C++11)
Biblioteca de control de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas

es.cppreference.net

Namespaces

Variants