Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::enumerate_view
Member functions
(C++26)
Deduction guides
Nested classes
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 /* siehe unten */

constexpr /* siehe unten */ 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 Range-Adapter, der eine view nimmt und eine Ansicht von tuple s erzeugt. Das i te Element (das Tupel) der resultierenden Sequenz enthält:
  • den Wert gleich i , welches ein nullbasierter Index des Elements der zugrundeliegenden Sequenz ist, und
  • die Referenz auf das zugrundeliegende Element.
2) Der Name views::enumerate bezeichnet ein RangeAdaptorObject . Für einen gegebenen Subausdruck e ist der Ausdruck views :: enumerate ( e ) ausdrucksäquivalent zu enumerate_view < views:: all_t < decltype ( ( e ) ) >> ( e ) für jeden geeigneten Subausdruck e .
3) Stellt sicher, dass der Referenztyp des zugrundeliegenden 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 zugrundeliegende View V die jeweiligen Konzepte modelliert.

Inhaltsverzeichnis

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