Namespaces
Variants

    std::ranges::views::enumerate, std::ranges::enumerate_view

    Von de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    Bereichsadapter
     
    std::ranges::enumerate_view
    Mitgliedsfunktionen
    (C++26)
    Ableitungsregeln
    Verschachtelte Klassen
    Iterator
    Sentinel
     
    Definiert im Header <ranges> 
    template< ranges::view V >
    requires /*range-with-movable-references*/<V>
class enumerate_view
    : public ranges::view_interface<enumerate_view<V>>
    		(1) (seit C++23) 
    namespace views {
    inline constexpr /* unspecified */ enumerate = /* unspecified */;
}
    		(2) (seit C++23)
    Aufrufsignatur
    		 
    template< ranges::viewable_range R >
    requires /* see below */
constexpr /* see below */ enumerate( R&& r );
    		(seit C++23)
    Hilfskonzepte
    		 
    template< class R >
    concept /*range-with-movable-references*/ =
        ranges::input_range<R> &&
        std::move_constructible<ranges::range_reference_t<R>> &&
        std::move_constructible<ranges::range_rvalue_reference_t<R>>;
    		(3) (nur zur Darstellung*)
    1) enumerate_view ist ein Bereichsadapter, der eine view nimmt und eine Ansicht von std::tuples erzeugt. Das ith Element (das Tupel) der resultierenden Sequenz enthält:
    • den Wert gleich i, welcher ein nullbasierter Index des Elements der zugrunde liegenden Sequenz ist, und
    • die Referenz auf das zugrunde liegende Element.
    2) Der Name views::enumerate bezeichnet ein RangeAdaptorObject. Gegeben ein Teilausdruck e, ist der Ausdruck views::enumerate(e) ausdrucksäquivalent zu enumerate_view<views::all_t<decltype((e))>>(e) für jeden geeigneten Teilausdruck e.
    3) Stellt sicher, dass der Referenztyp des zugrunde liegenden Typs verschoben werden kann.

    enumerate_view modelliert die Konzepte random_access_range, bidirectional_range, forward_range, input_range, common_range und sized_range, wenn die zugrunde liegende Ansicht V die jeweiligen Konzepte modelliert.

    Datenmitglieder

    Member Beschreibung
    V base_ ein Iterator zum zugrundeliegenden view
    ( Nur-Darstellungs-Memberobjekt* )

    Memberfunktionen

    		konstruiert einen enumerate_view
    (öffentliche Elementfunktion)
    		gibt eine Kopie der zugrundeliegenden (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 zugrundeliegende (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 Sicht leer ist, nur bereitgestellt, wenn sie sized_range oder forward_range
    (öffentliche Mitgliedsfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen konstanten Iterator zum Beginn des Bereichs zurück
    (öffentliche Mitgliedsfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen Sentinel für den konstanten Iterator des Bereichs zurück
    (öffentliche Mitgliedsfunktion von std::ranges::view_interface<D>)
    		gibt zurück, ob die abgeleitete Sicht nicht leer ist, nur bereitgestellt, wenn ranges::empty darauf anwendbar ist
    (öffentliche Mitgliedsfunktion von std::ranges::view_interface<D>)
    		gibt das erste Element in der abgeleiteten Sicht zurück, bereitgestellt, wenn sie forward_range
    (öffentliche Mitgliedsfunktion von std::ranges::view_interface<D>)
    		gibt das letzte Element in der abgeleiteten Sicht zurück, nur bereitgestellt, wenn sie bidirectional_range und common_range
    (öffentliche Mitgliedsfunktion von std::ranges::view_interface<D>)
    		gibt das nth Element in der abgeleiteten Sicht zurück, nur bereitgestellt, wenn sie random_access_range
    (öffentliche Mitgliedsfunktion von std::ranges::view_interface<D>)

    Deduktion Guides

    Geschachtelte Klassen

    (C++23)
    		der Iteratortyp
    ( Nur zur Darstellung verwendete Memberklassenvorlage* )
    (C++23)
    		der Sentineltyp
    ( Nur zur Darstellung verwendete Memberklassenvorlage* )

    Hilfsvorlagen

    template < class View >

    constexpr bool enable_borrowed_range < ranges :: enumerate_view < View >> =

    ranges:: enable_borrowed_range < View > ;
    		(seit C++23)

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

    Hinweise

    Feature-Test Makro Wert Standard Funktion
    __cpp_lib_ranges_enumerate 202302L (C++23) std::ranges::enumerate_view

    Beispiel

    Diesen Code ausführen 
    #include <initializer_list>
#include <iostream>
#include <map>
#include <ranges>
#include <vector>
int main()
{
    constexpr static auto v = {'A', 'B', 'C', 'D'};
    for (auto const [index, letter] : std::views::enumerate(v))
        std::cout << '(' << index << ':' << letter << ") ";
    std::cout << '\n';
#if __cpp_lib_ranges_to_container
    // Erstelle eine Map mit der Position jedes Elements als Schlüssel
    auto m = v | std::views::enumerate | std::ranges::to<std::map>();
    for (auto const [key, value] : m)
        std::cout << '[' << key << "]:" << value << ' ';
    std::cout << '\n';
#endif
    std::vector<int> numbers{1, 3, 5, 7};
    // num ist veränderbar trotz const, was sich nicht auf die Referenz überträgt
    // Um es konstant zu machen, verwende `std::views::enumerate(numbers) | std::views::as_const`
    // oder `std::views::enumerate(std::as_const(numbers))`
    for (auto const [index, num] : std::views::enumerate(numbers))
    {
        ++num; // der Typ ist int&
        std::cout << numbers[index] << ' ';
    }
    std::cout << '\n';
}

    Mögliche Ausgabe: 

    (0:A) (1:B) (2:C) (3:D)
[0]:A [1]:B [2]:C [3]:D
2 4 6 8

    Referenzen

    • C++23-Standard (ISO/IEC 14882:2024):
    • 26.7.23 Enumerate-Ansicht [range.enumerate]

    Siehe auch

    (C++20)
    		eine view bestehend aus einer Sequenz, die durch wiederholtes Inkrementieren eines Anfangswerts erzeugt wird
    (Klassentemplate) (Customization Point Object)
    (C++23)
    		eine view bestehend aus Tupeln von Referenzen auf entsprechende Elemente der adaptierten Views
    (Klassentemplate) (Customization Point Object)
    (C++20)
    		nimmt eine view bestehend aus tuple-like Werten und eine Zahl N und erzeugt eine view des N ten Elements jedes Tupels
    (Klassentemplate) (Range Adaptor Object)