Namespaces
Variants

    std::ranges::subrange

    Von de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    Range-Adaptoren
     
    std::ranges::subrange
     
    Definiert in 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*/ =
    /* see description */;
    		(2) (nur zur Darstellung*) 
    template<class From, class To>
concept /*convertible-to-non-slicing*/ = /* see description */;
    		(3) (nur zur Darstellung*)
    1) Die subrange-Klassenvorlage fasst einen Iterator und einen Sentinel in einem einzigen view zusammen. Sie modelliert sized_range, wenn der letzte Vorlagenparameter subrange_kind​::​sized ist (was der Fall ist, wenn std::sized_sentinel_for<S, I> erfüllt ist oder die Größe explizit als Konstruktorargument übergeben wird).
    2) Bestimmt, ob From in To ohne Qualifikationskonvertierungen konvertierbar ist. Äquivalent zu: 
    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 in To ohne Ableitung-zu-Basis-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>>;

    Datenelemente

    Element Beschreibung
    constexpr bool StoreSize [static] K == ranges::subrange_kind::sized &&
        !std::sized_sentinel_for<S, I>
    (nur zur Darstellung, statische Elementkonstante*)
    I begin_ ein Iterator zum Anfang des Teilbereichs
    (nur zur Darstellung, Elementobjekt*)
    S end_ eine Endmarkierung, die das Ende des Teilbereichs angibt
    (nur zur Darstellung, Elementobjekt*)
    make-unsigned-like-t <std::iter_difference_t<I>> size_
    (nur vorhanden, wenn StoreSize gleich true ist)     		die Größe des Teilbereichs
    (nur zur Darstellung, Elementobjekt*)

    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 ranges::view_interface
    (C++23)
    		 gibt einen konstanten Iterator zum Beginn der Bereichs zurück
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen Sentinel für den konstanten Iterator der Bereichs zurück
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt zurück, ob die abgeleitete Sicht nicht leer ist, nur bereitgestellt, wenn ranges::empty auf sie anwendbar ist
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		ermittelt die Adresse der Daten der abgeleiteten Sicht, nur bereitgestellt, wenn ihr Iteratortyp contiguous_iterator
    erfüllt (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das erste Element in der abgeleiteten Sicht zurück, bereitgestellt, wenn sie forward_range
    erfüllt (öffentliche Elementfunktion 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
    erfüllt (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das nte Element in der abgeleiteten Sicht zurück, nur bereitgestellt, 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