Namespaces
Variants

std::ranges:: subrange

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::subrange
Definiert im Header <ranges>
template <

std:: input_or_output_iterator I,
std:: sentinel_for < I > S = I,
ranges:: subrange_kind K = std:: sized_sentinel_for < S, I > ?
ranges :: subrange_kind :: sized :
ranges :: subrange_kind :: unsized >
requires ( K == ranges :: subrange_kind :: sized || ! std:: sized_sentinel_for < S, I > )
class subrange

: public ranges:: view_interface < subrange < I, S, K >>
(1) (seit C++20)
Hilfskonzepte
template < class From, class To >

concept /*uses-nonqualification-pointer-conversion*/ =

/* siehe Beschreibung */ ;
(2) ( Nur zur Darstellung* )
template < class From, class To >
concept /*convertible-to-non-slicing*/ = /* siehe Beschreibung */ ;
(3) ( Nur zur Darstellung* )
1) Die subrange -Klassenvorlage kombiniert einen Iterator und einen Sentinel zu einer einzelnen view . Sie modelliert sized_range , wenn der letzte Template-Parameter subrange_kind​ :: ​sized ist (was der Fall ist, wenn std:: sized_sentinel_for < S, I > erfüllt ist oder wenn die Größe explizit als Konstruktorargument übergeben wird).
2) Bestimmt, ob From zu To ohne Qualifikationskonvertierungen konvertierbar ist. Entspricht: 
template<class From, class To>
concept /*uses-nonqualification-pointer-conversion*/ =
    std::is_pointer_v<From> && std::is_pointer_v<To> &&
        !std::convertible_to<std::remove_pointer_t<From>(*)[],
                             std::remove_pointer_t<To>(*)[]>;
3) Bestimmt, ob From zu To ohne Derived-to-Base-Konvertierung konvertierbar ist: 
template<class From, class To>
concept /*convertible-to-non-slicing*/ =
    std::convertible_to<From, To> &&
        !/*uses-nonqualification-pointer-conversion*/
            <std::decay_t<From>, std::decay_t<To>>;

Inhaltsverzeichnis

Datenmitglieder

Mitglied Definition
constexpr bool StoreSize [static] K == ranges :: subrange_kind :: sized &&
! std:: sized_sentinel_for < S, I >
( Nur zur Darstellung verwendete statische Memberkonstante* )
I begin_ ein Iterator zum Anfang des Subbereichs
( Nur zur Darstellung verwendetes Memberobjekt* )
S end_ ein Sentinel, der das Ende des Subbereichs markiert
( Nur zur Darstellung verwendetes Memberobjekt* )
make-unsigned-like-t  < std:: iter_difference_t < I >> size_
(nur vorhanden, wenn StoreSize true ist) 		die Größe des Subbereichs
( Nur zur Darstellung verwendetes Memberobjekt* )

Memberfunktionen

erstellt einen neuen subrange
(öffentliche Elementfunktion)
konvertiert den subrange in einen pair-like Typ
(öffentliche Elementfunktion)
Beobachter
erhält den Iterator
(öffentliche Elementfunktion)
erhält den Sentinel
(öffentliche Elementfunktion)
prüft, ob der subrange leer ist
(öffentliche Elementfunktion)
erhält die Größe des subrange
(öffentliche Elementfunktion)
Iterator-Operationen
bewegt den Iterator um eine gegebene Distanz
(öffentliche Elementfunktion)
erhält eine Kopie des subrange mit seinem Iterator um eine gegebene Distanz dekrementiert
(öffentliche Elementfunktion)
erhält eine Kopie des subrange mit seinem Iterator um eine gegebene Distanz inkrementiert
(öffentliche Elementfunktion)
Geerbt von std::ranges::view_interface
(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> )
erhält die Adresse der Daten der abgeleiteten Ansicht, bereitgestellt nur wenn ihr Iteratortyp contiguous_iterator erfüllt
(ö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> )

Deduction-Guides

Nicht-Member-Funktionen

(C++20)
erhält Iterator oder Sentinel aus einem std::ranges::subrange
(Funktions-Template)

Hilfstypen

(C++20)
spezifiziert, ob ein std::ranges::subrange das Konzept std::ranges::sized_range modelliert
(Enumeration)
(C++20)
ermittelt die Größe eines std::ranges::subrange
(Klassentemplatespezialisierung)
(C++20)
ermittelt den Typ des Iterators oder des Sentinels eines std::ranges::subrange
(Klassentemplatespezialisierung)

Hilfsvorlagen

template < class I, class S, ranges:: subrange_kind K >
constexpr bool ranges:: enable_borrowed_range < ranges :: subrange < I, S, K >> = true ;
(seit C++20)

Diese Spezialisierung von ranges:: enable_borrowed_range bewirkt, dass subrange die Anforderungen von borrowed_range erfüllt.

Beispiel

Diesen Code ausführen 
#include <map>
#include <print>
#include <ranges>
void make_uppercase(char& v)
{
    v += 'A' - 'a';
}
void uppercase_transform(std::multimap<int, char>& m, int k)
{
    auto [first, last] = m.equal_range(k);
    for (auto& [_, v] : std::ranges::subrange(first, last))
        make_uppercase(v);
}
int main()
{
    std::multimap<int, char> mm{{4, 'a'}, {3, '-'}, {4, 'b'}, {5, '-'}, {4, 'c'}};
    std::println("Before: {}", mm);
    uppercase_transform(mm, 4);
    std::println("After:  {}", mm);
}

Ausgabe: 

Before: {3: '-', 4: 'a', 4: 'b', 4: 'c', 5: '-'}
After:  {3: '-', 4: 'A', 4: 'B', 4: 'C', 5: '-'}

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 3470 C++20 convertible-to-non-slicing könnte Qualifikationskonvertierungen ablehnen akzeptiert sie immer

Siehe auch

(C++20)
Hilfsklassen-Template zur Definition einer view unter Verwendung des Curiously Recurring Template Pattern
(Klassen-Template)

Externe Links

Lesen/Schreiben aller Werte eines std::multimap mit einem gegebenen Schlüssel in C++20 — SO