std::ranges::subrange

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Bereichsbibliothek

Bereichszugriff begin cbegin   end cend rbegin crbegin   rend crend size ssize   data cdata reserve_hint (C++26)   empty

Range-Konvertierungen std::from_range_t std::from_range (C++23)(C++23)     to (C++23)

Behandlung von hängenden Iteratoren dangling borrowed_iterator_t borrowed_subrange_t

Range-Primitive
range_size_trange_difference_trange_value_t elements_of (C++23)	iterator_tconst_iterator_tsentinel_tconst_sentinel_t (C++23)(C++23)	range_reference_trange_const_reference_trange_rvalue_reference_trange_common_reference_t (C++23)

Range-Konzepte
range borrowed_range    common_range	sized_range viewable_range    view	input_range output_range forward_range	bidirectional_range    random_access_range contiguous_range	approximately_sized_range (C++26) constant_range (C++23)

Ansichten
view_interface	subrange

Range-Fabriken
empty_viewviews::empty	single_viewviews::single	basic_istream_viewviews::istream	iota_viewviews::iota	repeat_viewviews::repeat (C++23)(C++23)

Range-Adaptoren
views::all_tviews::all as_rvalue_viewviews::as_rvalue (C++23)(C++23)   filter_viewviews::filter transform_viewviews::transform take_viewviews::take take_while_viewviews::take_while common_viewviews::common views::counted to_input_viewviews::to_input (C++26)(C++26)	ref_view drop_viewviews::drop drop_while_viewviews::drop_while lazy_split_viewviews::lazy_split split_viewviews::split join_viewviews::join join_with_viewviews::join_with (C++23)(C++23)   concat_viewviews::concat (C++26)(C++26) cache_latest_viewviews::cache_latest (C++26)(C++26)	owning_view reverse_viewviews::reverse as_const_viewviews::as_const (C++23)(C++23) elements_viewviews::elements keys_viewviews::keys values_viewviews::values enumerate_viewviews::enumerate (C++23)(C++23) zip_viewviews::zip (C++23)(C++23) zip_transform_viewviews::zip_transform (C++23)(C++23)	adjacent_viewviews::adjacent (C++23)(C++23) views::pairwise (C++23) adjacent_transform_viewviews::adjacent_transform (C++23)(C++23) views::pairwise_transform (C++23) chunk_viewviews::chunk (C++23)(C++23) slide_viewviews::slide (C++23)(C++23) chunk_by_viewviews::chunk_by (C++23)(C++23) stride_viewviews::stride (C++23)(C++23) cartesian_product_viewviews::cartesian_product (C++23)(C++23)

Range generators std::generator (C++23)

Range-Adaptor-Closure-Objekte range_adaptor_closure (C++23)

Range-Adaptor-Objekte

Hilfselemente
copyable-box movable-box (bis C++23)  (C++23)	simple-view non-propagating-cache

 

std::ranges::subrange

Memberfunktionen

subrange::subrange

subrange::operator PairLike

Observer

subrange::begin

subrange::end

subrange::empty

subrange::size

Iterator-Operationen

subrange::advance

subrange::next

subrange::prev

Deduction Guides

Nicht-Member-Funktionen

get(std::ranges::subrange)

Hilfstypen

subrange_kind

tuple_size<std::ranges::subrange>

tuple_element<std::ranges::subrange>

 

Definiert in der Header-Datei <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 Exposition*)
template<class From, class To> concept /*convertible-to-non-slicing*/ = /* siehe Beschreibung */;	(3)	(nur Exposition*)

1) Die Klassenvorlage subrange kombiniert einen Iterator und einen Sentinel zu einer einzigen view. Sie modelliert sized_range, wenn der letzte Template-Parameter subrange_kind​::​sized ist (was geschieht, wenn std::sized_sentinel_for<S, I> erfüllt ist oder wenn die Größe explizit als Konstruktorargument übergeben wird).

2) Bestimmt, ob From ohne Qualifizierungskonvertierungen in To 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 ohne abgeleitete-zu-Basis-Konvertierung in To 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

Mitglied	Definition
constexpr bool StoreSize [statisch]	K == ranges::subrange_kind::sized &&     !std::sized_sentinel_for<S, I> ((exposition-only static member constant*)
I begin_	ein Iterator zum Anfang des Teilbereichs ((exposition-only member object*)
S end_	ein Sentinel, der das Ende des Teilbereichs kennzeichnet ((exposition-only member object*)
make-unsigned-like-t <std::iter_difference_t<I>> size_ (nur vorhanden, wenn StoreSize true ist)	die Größe des Teilbereichs ((exposition-only member object*)

Member-Funktionen

(Konstruktor)	erzeugt einen neuen subrange (öffentliche Memberfunktion)
operator PairLike	konvertiert den subrange in einen paar-ähnlichen Typ (public member function)
Observer
begin	holt den Iterator (public member function)
end	holt den Sentinel (public member function)
empty	prüft, ob der subrange leer ist (public member function)
size	holt die Größe des subrange (public member function)
Iterator-Operationen
advance	verschiebt den Iterator um den gegebenen Abstand (public member function)
prev	holt eine Kopie des subrange, bei der der Iterator um einen gegebenen Abstand dekrementiert wurde (public member function)
next	holt eine Kopie des subrange, bei der der Iterator um einen gegebenen Abstand avanciert wurde (public member function)
Geerbt von std::ranges::view_interface
cbegin (C++23)	gibt einen konstanten Iterator zum Anfang des Bereichs zurück (public member function of std::ranges::view_interface<D>)
cend (C++23)	gibt ein Sentinel für den konstanten Iterator des Bereichs zurück (public member function of std::ranges::view_interface<D>)
operator bool	gibt zurück, ob die abgeleitete Ansicht nicht leer ist, bereitgestellt nur, wenn ranges::empty darauf anwendbar ist (public member function of std::ranges::view_interface<D>)
data	gibt die Adresse der Daten der abgeleiteten Ansicht zurück, nur bereitgestellt, wenn ihr Iteratortyp contiguous_iterator erfüllt (öffentliche Memberfunktion von std::ranges::view_interface<D>)
front	gibt das erste Element in der abgeleiteten View zurück, bereitgestellt, wenn sie forward_range erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)
back	gibt das letzte Element in der abgeleiteten View zurück, nur bereitgestellt, wenn sie bidirectional_range und common_range erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)
operator[]	gibt das n-te Element in der abgeleiteten View zurück, nur bereitgestellt, wenn sie random_access_range erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)

Nicht-Member-Funktionen

get(std::ranges::subrange) (C++20)

holt Iterator oder Sentinel aus einem std::ranges::subrange (Funktionsvorlage)

Hilfstypen

ranges::subrange_kind (C++20)	spezifiziert, ob ein std::ranges::subrange std::ranges::sized_range modelliert (enum)
std::tuple_size<std::ranges::subrange> (C++20)	holt die Größe eines std::ranges::subrange (Klassentemplate-Spezialisierung)
std::tuple_element<std::ranges::subrange> (C++20)	holt den Typ des Iterators oder des Sentinels eines std::ranges::subrange (Klassentemplate-Spezialisierung)

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 lässt subrange borrowed_range erfüllen.

Beispiel

Führen Sie diesen Code aus

#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	Korrigiertes Verhalten
LWG 3470	C++20	convertible-to-non-slicing könnte Qualifizierungskonvertierungen ablehnen	akzeptiert sie immer

Siehe auch

ranges::view_interface (C++20)

Hilfsklassen-Template zur Definition eines view unter Verwendung des Curiously Recurring Template Pattern (Klassen-Template)

Externe Links

Lese/schreibe alle Werte einer std::multimap mit einem bestimmten Schlüssel in C++20 — SO