std::ranges::join_with_view<V,Pattern>::iterator

 

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::join_with_view

Memberfunktionen

join_with_view::join_with_view

join_with_view::base

join_with_view::begin

join_with_view::end

Deduction Guides

Iterator

Memberfunktionen

join_with_view::iterator::iterator

join_with_view::iterator::operator*

join_with_view::iterator::operator++ join_with_view::iterator::operator++(int) join_with_view::iterator::operator-- join_with_view::iterator::operator--(int)

Nicht-Member-Funktionen

operator==(join_with_view::iterator) (C++23)

iter_move(join_with_view::iterator) (C++23)

iter_swap(join_with_view::iterator) (C++23)

Sentinel

join_with_view::sentinel::sentinel

operator==(join_with_view::sentinel) (C++23)

 

template< bool Const > class /*iterator*/		(nur Exposition*)

ranges::join_with_view<V, Pattern>::iterator ist der Typ der Iteratoren, die von begin() und end() von ranges::join_with_view<V, Pattern> zurückgegeben werden.

Der Zustand eines Iterators dieser Klasse wird so verwaltet, als gäbe es zwei verschachtelte Iteratoren

• ein äußerer Iterator in den übergeordneten Bereich *parent_

• Wenn Base forward_range modelliert, ist es outer_it_.
• Andernfalls ist es parent_ ->outer_it_.

• ein innerer Iterator inner_it_ in den Musterbereich parent_ ->pattern_ oder in einen Unterbereich des übergeordneten Bereichs

Diese Iterator-Klasse hat die Invariante, dass der innere Iterator immer dereferenzierbar ist, es sei denn, der äußere Iterator ist nicht dereferenzierbar. Wenn ein Iterator konstruiert, inkrementiert oder dekrementiert wird, kann sein äußerer Iterator angepasst werden, um die Invariante zu wahren.

Template-Parameter

Const

-

ob der Iterator ein konstanter Iterator ist

Verschachtelte Typen

Nur-Exposition-Typen
Typ	Definition
Parent	maybe-const <Const, ranges::join_with_view<V, Pattern>> ((nur zur Veranschaulichung)*)
Base	maybe-const <Const, V> ((nur zur Veranschaulichung)*)
InnerBase	ranges::range_reference_t<Base > ((nur zur Veranschaulichung)*)
PatternBase	maybe-const <Const, Pattern> ((nur zur Veranschaulichung)*)
OuterIter	ranges::iterator_t<Base > ((nur zur Veranschaulichung)*)
InnerIter	ranges::iterator_t<InnerBase > ((nur zur Veranschaulichung)*)
PatternIter	ranges::iterator_t<PatternBase > ((nur zur Veranschaulichung)*)
Iterator-Eigenschaftstypen
Typ	Definition
iterator_concept	ein Iterator-Tag, siehe unten
iterator_category (bedingt vorhanden)	ein Iterator-Tag, siehe unten
value_type	std::common_type_t<ranges::range_value_t<InnerBase >,                    ranges::range_value_t<PatternBase >>
difference_type	std::common_type_t<ranges::range_difference_t<Base >,                    ranges::range_difference_t<InnerBase >,                    ranges::range_difference_t<PatternBase >>

Bestimmung des Iterator-Konzepts

iterator_concept ist wie folgt definiert

• Wenn alle folgenden Bedingungen erfüllt sind, bezeichnet iterator_concept std::bidirectional_iterator_tag
  • std::is_reference_v<InnerBase > ist true.
  • Base modelliert bidirectional_range.
  • InnerBase und PatternBase modellieren jeweils common_range.
• Andernfalls, wenn alle folgenden Bedingungen erfüllt sind, bezeichnet iterator_concept std::forward_iterator_tag
  • std::is_reference_v<InnerBase > ist true.
  • Base und InnerBase modellieren jeweils forward_range.
• Andernfalls bezeichnet iterator_concept std::input_iterator_tag.

Bestimmung der Iterator-Kategorie

Gegeben die folgenden Typen

• Sei OuterC std::iterator_traits<OuterIter >::iterator_category.
• Sei InnerC std::iterator_traits<InnerIter >::iterator_category.
• Sei PatternC std::iterator_traits<PatternIter >::iterator_category.

iterator_category ist definiert genau dann, wenn std::is_reference_v<InnerBase > true ist und Base und InnerBase jeweils forward_range modellieren. In diesem Fall ist es wie folgt definiert

• Wenn std::is_reference_v<std::common_reference_t<ranges::range_reference_t<InnerBase >,
                                              ranges::range_reference_t<PatternBase >> ist false, bezeichnet iterator_category std::input_iterator_tag.
• Andernfalls, wenn alle folgenden Bedingungen erfüllt sind, bezeichnet iterator_category std::bidirectional_iterator_tag
  • OuterC, InnerC und PatternC modellieren jeweils std::derived_from<std::bidirectional_iterator_tag>.
  • InnerBase und PatternBase modellieren jeweils common_range.
• Andernfalls, wenn OuterC, InnerC und PatternC jeweils std::derived_from<std::forward_iterator_tag> modellieren, bezeichnet iterator_category std::forward_iterator_tag.
• Andernfalls bezeichnet iterator_category std::input_iterator_tag.

Datenmember

Mitglied	Beschreibung
Parent * parent_	der Zeiger auf die übergeordnete join_with_view ((exposition-only member object*)
OuterIter outer_it_ (nur vorhanden, wenn Base forward_range modelliert)	der äußere Iterator ((exposition-only member object*)
std::variant<PatternIter , InnerIter > inner_it_	der innere Iterator ((exposition-only member object*)

Member-Funktionen

(Konstruktor)	Konstruiert einen Iterator (öffentliche Memberfunktion)
operator*	greift auf das Element zu (öffentliche Memberfunktion)
operator++operator++(int)operator--operator--(int)	bewegt den zugrundeliegenden Iterator vorwärts oder rückwärts (public member function)

Nicht-Member-Funktionen

operator== (C++23)	vergleicht die zugrundeliegenden Iteratoren (Funktion)
iter_move (C++23)	castet das Ergebnis der Dereferenzierung des zugrundeliegenden Iterators in seinen zugehörigen rvalue-Referenztyp (Funktion)
iter_swap (C++23)	tauscht die Objekte, auf die zwei zugrundeliegende Iteratoren zeigen (Funktion)