Namespaces
Variants

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

    Von de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    Range-Adaptoren
     
    std::ranges::elements_view
    Mitgliedsfunktionen
    (C++26)
    Verschachtelte Klassen
    Iterator
    Sentinel
     
    Definiert in Header <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) (seit C++20) 
    namespace views {
    template< std::size_t N >
    constexpr /* unspecified */ elements = /* unspecified */;
}
    		(2) (seit C++20)
    Aufrufsignatur
    		 
    template< ranges::viewable_range R >
    requires /* see below */
constexpr ranges::view auto elements<N>( R&& r );
    		(seit C++20)
    Hilfskonzepte
    		 
    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>&>;
    };
    		(3) (bis C++23)
    (nur zur Darstellung*)    		 
    template< class T, std::size_t N >
concept /*has-tuple-element*/ =
    /*tuple-like*/<T> && N < std::tuple_size_v<T>
    		(seit C++23)
    (nur zur Darstellung*)    		 
    template< class T, std::size_t N >
concept returnable-element =
     std::is_reference_v<T> || std::move_constructible<
                                       std::tuple_element_t<N, T>>;
    		(4) (nur zur Darstellung*)
    1) Akzeptiert eine view von tupelartigen Werten und gibt eine view mit einem Werttyp des Nten Elements des Werttyps der angepassten view aus.
    2) Jede Spezialisierung von views::elements ist ein RangeAdaptorObject. Der Ausdruck views::elements<M>(e) ist ausdrucksäquivalent zu elements_view<views::all_t<decltype((e))>, M>{e} für jede geeignete Unterexpression e und konstante Expression M.
    3) Stellt sicher, dass die Elemente der zugrunde liegenden view tupelartige Werte sind, siehe tupelartig(seit C++23).
    4) Stellt sicher, dass keine hängenden Referenzen zurückgegeben werden können.

    elements_view modelliert die Konzepte random_access_range, bidirectional_range, forward_range, input_range, common_range und sized_range, wenn die zugrunde liegende view V die entsprechenden Konzepte modelliert.

    Datenmitglieder

    Mitglied Beschreibung
    V base_ die zugrundeliegende Ansicht
    ( Nur zur Darstellung verwendetes Mitgliedsobjekt* )

    Memberfunktionen

    		konstruiert eine elements_view
    (öffentliche Elementfunktion)
    		gibt eine Kopie der zugrunde liegenden (adaptierten) Ansicht zurück
    (öffentliche Elementfunktion)
    		gibt einen Iterator zum Anfang zurück
    (öffentliche Elementfunktion)
    		gibt einen Iterator oder Sentinel zum Ende zurück
    (öffentliche Elementfunktion)
    		gibt die Anzahl der Elemente zurück, bereitgestellt nur wenn der zugrunde liegende (adaptierte) Bereich sized_range erfüllt
    (öffentliche Elementfunktion)
    (C++26)
    		gibt die ungefähre Größe des resultierenden approximately_sized_range zurück
    (öffentliche Elementfunktion)
    Geerbt von ranges::view_interface
    		gibt zurück, ob die abgeleitete Ansicht leer ist, nur wenn sie sized_range oder forward_range
    erfüllt (öffentliche Memberfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen konstanten Iterator zum Beginn des Bereichs zurück
    (öffentliche Memberfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen Sentinel für den konstanten Iterator des Bereichs zurück
    (öffentliche Memberfunktion von std::ranges::view_interface<D>)
    		gibt zurück, ob die abgeleitete Ansicht nicht leer ist, nur wenn ranges::empty darauf anwendbar ist
    (öffentliche Memberfunktion von std::ranges::view_interface<D>)
    		gibt das erste Element in der abgeleiteten Ansicht zurück, nur wenn sie forward_range
    erfüllt (öffentliche Memberfunktion von std::ranges::view_interface<D>)
    		gibt das letzte Element in der abgeleiteten Ansicht zurück, nur wenn sie bidirectional_range und common_range
    erfüllt (öffentliche Memberfunktion von std::ranges::view_interface<D>)
    		gibt das n-te Element in der abgeleiteten Ansicht zurück, nur wenn sie random_access_range
    erfüllt (öffentliche Memberfunktion von std::ranges::view_interface<D>)

    Geschachtelte Klassen

    		der Iteratortyp
    ( Nur zur Darstellung verwendete Member-Klassentemplate* )
    		der Sentineltyp
    ( Nur zur Darstellung verwendete Member-Klassentemplate* )

    Hilfsvorlagen

    template < class T, std:: size_t N >

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

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

    Diese Spezialisierung von ranges::enable_borrowed_range bewirkt, dass elements_view borrowed_range erfüllt, wenn die zugrundeliegende View diese Bedingung erfüllt.

    Beispiel

    Diesen Code ausführen 
    #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';
}

    Ausgabe: 

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

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    LWG 3494 C++20 elements_view war nie ein borrowed_range es ist ein borrowed_range
    wenn seine zugrunde liegende Ansicht es ist
    LWG 3502 C++20 Hängende Referenz konnte von elements_view erhalten werden solche Verwendung ist verboten

    Siehe auch

    (C++20)
    		nimmt eine view bestehend aus paarartigen Werten und erzeugt eine view der ersten Elemente jedes Paares
    (Klassen-Template) (Range-Adapter-Objekt)
    (C++20)
    		nimmt eine view bestehend aus paarartigen Werten und erzeugt eine view der zweiten Elemente jedes Paares
    (Klassen-Template) (Range-Adapter-Objekt)
    (C++23)
    		eine view bestehend aus Tupeln von Referenzen zu entsprechenden Elementen der adaptierten Views
    (Klassen-Template) (Customization Point Object)
    (C++23)
    		eine view bestehend aus Ergebnissen der Anwendung einer Transformationsfunktion auf entsprechende Elemente der adaptierten Views
    (Klassen-Template) (Customization Point Object)
    		BLAS-ähnlicher Slice eines valarray: Startindex, Länge, Schrittweite
    (Klasse)