std::tuple_element<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< class I, class S, ranges::subrange_kind K > struct tuple_element<0, ranges::subrange<I, S, K>>;	(1)	(seit C++20)
template< class I, class S, ranges::subrange_kind K > struct tuple_element<0, const ranges::subrange<I, S, K>>;	(2)	(seit C++20)
template< class I, class S, ranges::subrange_kind K > struct tuple_element<1, ranges::subrange<I, S, K>>;	(3)	(seit C++20)
template< class I, class S, ranges::subrange_kind K > struct tuple_element<1, const ranges::subrange<I, S, K>>;	(4)	(seit C++20)

Die partiellen Spezialisierungen von std::tuple_element für std::ranges::subrange bieten zur Compile-Zeit Zugriff auf den Iterator- oder Sentinel-Typ eines subrange mittels Tupel-ähnlicher Syntax. Sie werden zur Unterstützung von Structured Bindings bereitgestellt.

1,2) Ermittelt den Iteratortyp, d.h. I.

3,4) Ermittelt den Sentinel-Typ, d.h. S.

Member types

Mitgliedertyp	Definition
type	(1,2) I (3,4) S

Notes

Da get-Funktionen für subrange Iteratoren und Sentinels per Wert zurückgeben, wird der const-Qualifikator nicht zu den Ergebnistypen hinzugefügt, wenn der subrange mit const qualifiziert ist (aber nicht mit volatile).

Wenn der subrange mit volatile qualifiziert ist, werden die Ergebnistypen ebenfalls mit volatile qualifiziert, da die partiellen Spezialisierungen für volatile oder const volatile Typen verwendet werden. Eine solche Verwendung ist veraltet.

Example

Führen Sie diesen Code aus

#include <iterator>
#include <list>
#include <ranges>
#include <type_traits>
 
int main()
{
    std::list<int> list{3, 1, 4, 1, 5, 9, 2, 6};
 
    std::ranges::subrange subrange
    {
        std::counted_iterator{std::begin(list), 4},
        std::default_sentinel
    };
 
    static_assert(
        std::is_same_v<
            std::tuple_element_t<0, decltype(subrange)>,
            // implementation-defined type:
            std::counted_iterator<std::_List_iterator<int>>
            >);
 
    static_assert(
        std::is_same_v<
            std::tuple_element_t<1, decltype(subrange)>,
            std::default_sentinel_t
            >);
}

See also

Strukturierte Bindung (C++17)	bindet die angegebenen Namen an Unterobjekte oder Tuple-Elemente des Initialisierers
tuple_element (C++11)	erhält die Elementtypen eines Tupel-ähnlichen Typs (Klassenvorlage)
std::tuple_size<std::ranges::subrange> (C++20)	erhält die Größe eines std::ranges::subrange (Klassentemplate-Spezialisierung)