elements_view (Clase, Biblioteca estándar de C++)
Vista sobre los elementos de un índice seleccionado en cada valor similar a la tupla de un intervalo. Por ejemplo, dado un intervalo de std::tuple<string, int>, cree una vista que consta de los string elementos de cada tupla.
Sintaxis
template<input_range V, size_t N>
class elements_view : public view_interface<elements_view<V, N>>;
Parámetros de plantilla
N
Índice del elemento que se va a seleccionar para la vista.
V
Tipo del intervalo subyacente. Este tipo debe satisfacer ranges::input_range.
Características de la vista
Para obtener una descripción de las siguientes entradas, vea View class characteristics (Ver características de clase).
| Característica | Descripción |
|---|---|
| Adaptador de rango | views::elements |
| Intervalo subyacente | Debe satisfacer input_range o superior |
| Tipo de elemento | Igual que el tipo del elemento de tupla indexada |
| Ver categoría de iterador | forward_range, bidirectional_rangeo random_access_range |
| Tamaño | Solo si el intervalo subyacente cumple sized_range |
Es const-iterable |
Solo si el intervalo subyacente cumple const-iterable |
| Rango común | Solo si el intervalo subyacente cumple common_range |
| Intervalo prestado | Solo si el intervalo subyacente cumple borrowed_range |
Miembros
| Funciones miembro | Descripción |
|---|---|
| ConstructoresC++20 | Construya un elemento elements_view. |
baseC++20 |
Obtenga el intervalo subyacente. |
beginC++20 |
Obtenga un iterador al primer elemento. |
endC++20 |
Obtenga el sentinel al final de la vista. |
sizeC++20 |
Obtenga el número de elementos de esta vista. El intervalo subyacente debe satisfacer sized_range. |
Heredado de view_interface |
Descripción |
backC++20 |
Obtenga el último elemento. |
emptyC++20 |
Comprueba si el objeto elements_view está vacío. |
frontC++20 |
Obtiene el primer elemento. |
operator[]C++20 |
Obtiene el elemento que se encuentra en la posición especificada. |
operator boolC++20 |
Compruebe si elements_view no está vacío. |
Requisitos
Encabezado: <ranges> (desde C++20)
Espacio de nombres: std::ranges
Opción del compilador: /std:c++20 o posterior es necesaria.
Comentarios
Los tipos similares a la tupla que se pueden usar con elements_view son std::tuple, std::pairy std::array.
Constructores
Construya una instancia de .elements_view
1) constexpr elements_view(V base);
2) elements_view() requires std::default_initializable<V> = default;
Parámetros
base
Intervalo subyacente.
Para obtener información sobre el tipo de parámetro de plantilla, consulte Parámetros de plantilla.
Valor devuelto
Instancia de elements_view.
Comentarios
La mejor manera de crear un elements_view es usar el adaptador de elements rango. Los adaptadores de rango son la manera prevista de crear clases de vista. Los tipos de vista se exponen en caso de que desee crear su propio tipo de vista personalizado.
1) Cree un elements_view a partir de la vista especificada.
2) Construcción predeterminada de .elements_view
Ejemplo: elements_view
// requires /std:c++20 or later
#include <array>
#include <iostream>
#include <map>
#include <ranges>
#include <vector>
#include <string>
#include <utility>
int main()
{
// ========== work with a std::map
std::map<std::string, int> cpp_standards
{
{"C++98", 1988},
{"C++03", 2003},
{"C++11", 2011},
{"C++14", 2014},
{"C++17", 2017},
{"C++20", 2020}
};
// create an elements_view of all the string elements (<1>) from each tuple
for (int const year : std::views::elements<1>(cpp_standards))
{
std::cout << year << ' '; // 2003 2011 2014 2017 1988 2020
}
std::cout << '\n';
// Another way to call the range adaptor using pipe (|) syntax
for (auto&& name : cpp_standards | std::views::elements<0>)
{
std::cout << name << ' '; // C++03 C++11 C++14 C++17 C++98 C++20
}
std::cout << '\n';
// ========== working with arrays
std::array<std::array<int, 4>, 3> arr = { {{0,1,2,3}, {4,5,6,7}, {8,9,10,11}} };
for (int& fourth : arr | std::views::elements<3>)
{
std::cout << fourth << ' '; // 3 7 11
}
std::cout << '\n';
// ========== work with a std::pair
std::vector<std::pair<std::string, int>> windows
{
{"Windows 1.0", 1985},
{"Windows 2.0", 1987},
{"Windows 3.0", 1990},
{"Windows 3.1", 1992},
{"Windows NT 3.1", 1993},
{"Windows 95", 1995},
{"Windows NT 4.0", 1996},
{"Windows 98", 1998},
{"Windows 2000", 2000}
};
for (int year : std::views::elements<1>(windows))
{
std::cout << year << ' '; // 1985 1987 1990 1992 1993 1995 1996 1998 2000
}
}
2003 2011 2014 2017 1988 2020
C++03 C++11 C++14 C++17 C++98 c++20
3 7 11
1985 1987 1990 1992 1993 1995 1996 1998 2000
base
Obtiene una copia del intervalo subyacente.
// Uses a copy constructor to return the underlying range
constexpr V base() const& requires std::copy_constructible<V>;
// Uses a move constructor to return the underlying range
constexpr V base() &&;
Parámetros
Ninguno.
Valor devuelto
Intervalo subyacente.
begin
Obtenga un iterador al primer elemento de .elements_view
1) constexpr auto begin() requires (!Simple_view<V>);
2) constexpr auto begin() const requires range<const V>;
Parámetros
Ninguno.
Valor devuelto
Iterador que apunta al primer elemento de elements_view.
end
Obtención del centinela al final del elements_view
1) constexpr auto end() requires (!Simple_view<V> && !ranges::common_range<V>);
2) constexpr auto end() requires (!Simple_view<V> && ranges::common_range<V>);
3) constexpr auto end() const requires ranges::range<const V>;
4) constexpr auto end() const requires ranges::common_range<const V>;
Parámetros
Ninguno.
Valor devuelto
Sentinel que sigue al último elemento de elements_view:
size
Obtiene el número de elementos de la vista.
constexpr auto size() requires sized_range<V>;
constexpr auto size() const requires sized_range<const V>;
Parámetros
Ninguno.
Valor devuelto
Número de elementos incluidos en elements_view.
Comentarios
El tamaño de la vista solo está disponible si el intervalo subyacente es , sized_rangeo en otras palabras, limitado.