Namespaces
Variants

std::ranges:: views:: elements, std::ranges:: elements_view

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::elements_view
Member functions
(C++26)
Nested classes
Iterator
Sentinel
Défini dans l'en-tête <ranges>
template < ranges:: input_range V, std:: size_t N >

requires ranges:: view < V > &&
/*has-tuple-element*/ < ranges:: range_value_t < V > , N > &&
/*has-tuple-element*/ < std:: remove_reference_t <
ranges:: range_reference_t < V >> , N > &&
/*returnable-element*/ < ranges:: range_reference_t < V > , N >
class elements_view

: public ranges:: view_interface < elements_view < V, N >> ;
(1) (depuis C++20)
namespace views {

template < std:: size_t N >
constexpr /* non spécifié */ elements = /* non spécifié */ ;

}
(2) (depuis C++20)
Signature d'appel
template < ranges:: viewable_range R >

requires /* voir ci-dessous */

constexpr ranges:: view auto elements < N > ( R && r ) ;
(depuis C++20)
Concepts auxiliaires
(3)
template < class T, std:: size_t N >

concept /*has-tuple-element*/ =
requires ( T t ) {
typename std:: tuple_size < T > :: type ;
requires N < std:: tuple_size_v < T > ;
typename std:: tuple_element_t < N, T > ;
{ std :: get < N > ( t ) } - > std:: convertible_to <
const std:: tuple_element_t < N, T > & > ;

} ;
(jusqu'en C++23)
( exposition uniquement* )
template < class T, std:: size_t N >

concept /*has-tuple-element*/ =

/*tuple-like*/ < T > && N < std:: tuple_size_v < T >
(depuis C++23)
( exposition uniquement* )
template < class T, std:: size_t N >

concept élément_retournable - élément =
std:: is_reference_v < T > || std:: move_constructible <

std:: tuple_element_t < N, T >> ;
(4) ( exposition uniquement* )
1) Accepte une view de valeurs de type tuple, et produit une vue dont le type de valeur est le N ème élément du type de valeur de la vue adaptée.
2) Toute spécialisation de views::elements est un RangeAdaptorObject . L'expression views :: elements < M > ( e ) est équivalente en expression à elements_view < views:: all_t < decltype ( ( e ) ) > , M > { e } pour toute sous-expression appropriée e et expression constante M .
3) Garantit que les éléments de la vue sous-jacente sont des valeurs de type tuple , voir tuple-like (depuis C++23) .
4) Garantit qu'aucune référence pendante ne peut être retournée.

elements_view modélise les concepts random_access_range , bidirectional_range , forward_range , input_range , common_range , et sized_range lorsque la vue sous-jacente V modélise les concepts respectifs.

Table des matières

Membres de données

Membre Description
V base_ la vue sous-jacente
( objet membre d'exposition uniquement* )

Fonctions membres

construit un elements_view
(fonction membre publique)
retourne une copie de la vue sous-jacente (adaptée)
(fonction membre publique)
retourne un itérateur vers le début
(fonction membre publique)
retourne un itérateur ou un sentinelle vers la fin
(fonction membre publique)
retourne le nombre d'éléments, fourni uniquement si la plage sous-jacente (adaptée) satisfait sized_range
(fonction membre publique)
(C++26)
retourne la taille approximative de la approximately_sized_range résultante
(fonction membre publique)
Hérité de std::ranges::view_interface
indique si la vue dérivée est vide, fourni uniquement si elle satisfait sized_range ou forward_range
(fonction membre publique de std::ranges::view_interface<D> )
(C++23)
retourne un itérateur constant vers le début de la plage
(fonction membre publique de std::ranges::view_interface<D> )
(C++23)
retourne un sentinelle pour l'itérateur constant de la plage
(fonction membre publique de std::ranges::view_interface<D> )
indique si la vue dérivée n'est pas vide, fourni uniquement si ranges::empty lui est applicable
(fonction membre publique de std::ranges::view_interface<D> )
retourne le premier élément de la vue dérivée, fourni si elle satisfait forward_range
(fonction membre publique de std::ranges::view_interface<D> )
retourne le dernier élément de la vue dérivée, fourni uniquement si elle satisfait bidirectional_range et common_range
(fonction membre publique de std::ranges::view_interface<D> )
retourne le n ème élément de la vue dérivée, fourni uniquement si elle satisfait random_access_range
(fonction membre publique de std::ranges::view_interface<D> )

Classes imbriquées

le type d'itérateur
( classe membre modèle d'exposition uniquement* )
le type de sentinelle
( classe membre modèle d'exposition uniquement* )

Modèles d'assistance

template < class T, std:: size_t N >

constexpr bool enable_borrowed_range < std :: ranges :: elements_view < T, N >> =

ranges:: enable_borrowed_range < T > ;
(depuis C++20)

Cette spécialisation de ranges::enable_borrowed_range permet à elements_view de satisfaire borrowed_range lorsque la vue sous-jacente la satisfait.

Exemple

Exécuter ce code 
#include <iostream>
#include <ranges>
#include <string>
#include <tuple>
#include <vector>
int main()
{
    const std::vector<std::tuple<int, char, std::string>> vt
    {
        {1, 'A', "α"},
        {2, 'B', "β"},
        {3, 'C', "γ"},
        {4, 'D', "δ"},
        {5, 'E', "ε"},
    };
    for (int const e : std::views::elements<0>(vt))
        std::cout << e << ' ';
    std::cout << '\n';
    for (char const e : vt | std::views::elements<1>)
        std::cout << e << ' ';
    std::cout << '\n';
    for (std::string const& e : std::views::elements<2>(vt))
        std::cout << e << ' ';
    std::cout << '\n';
}

Sortie : 

1 2 3 4 5
A B C D E
α β γ δ ε

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Applicable à Comportement publié Comportement corrigé
LWG 3494 C++20 elements_view n'a jamais été un borrowed_range c'est un borrowed_range
si sa vue sous-jacente l'est
LWG 3502 C++20 une référence pendante pouvait être obtenue depuis elements_view cet usage est interdit

Voir aussi

(C++20)
prend une view constituée de valeurs de type paire et produit une view des premiers éléments de chaque paire
(modèle de classe) (objet adaptateur de gamme)
(C++20)
prend une view constituée de valeurs de type paire et produit une view des deuxièmes éléments de chaque paire
(modèle de classe) (objet adaptateur de gamme)
(C++23)
une view constituée de tuples de références aux éléments correspondants des vues adaptées
(modèle de classe) (objet point de personnalisation)
(C++23)
une view constituée des résultats de l'application d'une fonction de transformation aux éléments correspondants des vues adaptées
(modèle de classe) (objet point de personnalisation)
tranche de type BLAS d'un valarray : index de départ, longueur, pas
(classe)