std::ranges::crbegin

 

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

 

Definiert in der Header-Datei <ranges>
Definiert in Header <iterator>
inline namespace /* nicht spezifiziert */ {     inline constexpr /* nicht spezifiziert */ crbegin = /* nicht spezifiziert */; }		(seit C++20) (Customization-Point-Objekt)
Aufruf-Signatur
template< class T >     requires /* siehe unten */ constexpr /* siehe unten */ auto crbegin( T&& t );		(seit C++20)

Gibt einen Iterator auf das erste Element des als konstante Folge behandelten Arguments zurück.	(bis C++23)
Gibt einen konstanten Iterator auf das erste Element des als umgekehrte Folge behandelten Arguments zurück.	(seit C++23)

Sei CT const std::remove_reference_t<T>& wenn das Argument ein lvalue ist (d.h. T ist ein lvalue-Referenztyp), const T andernfalls. Ein Aufruf von ranges::crbegin ist ausdrucksäquivalent zu ranges::rbegin(static_cast<CT&&>(t)).

(bis C++23)

Wenn das Argument ein lvalue ist oder ranges::enable_borrowed_range<std::remove_cv_t<T>> true ist, dann ist ein Aufruf von ranges::crbegin ausdrucksäquivalent zu std::const_iterator<decltype(U)>(U) für einen Ausdruck U, der ausdrucksäquivalent zu ranges::rbegin(possibly-const-range(t)) ist. In allen anderen Fällen ist ein Aufruf von ranges::crbegin ill-formed, was zu Substitution Failure führen kann, wenn der Aufruf im unmittelbaren Kontext einer Template-Instanziierung auftritt.

(seit C++23)

Der Rückgabetyp modelliert in allen Fällen std::input_or_output_iterator und constant-iterator(seit C++23).

Customization Point Objects

Der Name ranges::crbegin bezeichnet ein Customization Point Object, welches ein konstantes Funktionsobjekt eines literalen semiregular-Klassentyps ist. Zu Expositionszwecken wird die cv-unqualifizierte Version seines Typs als __crbegin_fn bezeichnet.

Alle Instanzen von __crbegin_fn sind gleich. Die Effekte des Aufrufs verschiedener Instanzen vom Typ __crbegin_fn auf dieselben Argumente sind äquivalent, unabhängig davon, ob der Ausdruck, der die Instanz bezeichnet, ein lvalue oder rvalue ist und ob er mit const qualifiziert ist oder nicht (eine volatile-qualifizierte Instanz muss jedoch nicht aufrufbar sein). Daher kann ranges::crbegin frei kopiert werden und seine Kopien können austauschbar verwendet werden.

Gegeben eine Menge von Typen Args..., wenn std::declval<Args>()... die Anforderungen für Argumente an ranges::crbegin erfüllt, dann modelliert __crbegin_fn

• std::invocable<__crbegin_fn, Args...>,
• std::invocable<const __crbegin_fn, Args...>,
• std::invocable<__crbegin_fn&, Args...>, und
• std::invocable<const __crbegin_fn&, Args...>.
  

Andernfalls nimmt kein Operator zum Aufrufen von __crbegin_fn an der Overload Resolution teil.

Beispiel

Führen Sie diesen Code aus

#include <cassert>
#include <iterator>
#include <span>
#include <vector>
 
int main()
{
    std::vector<int> v{3, 1, 4};
    auto vi = std::ranges::crbegin(v);
    assert(*vi == 4);
    ++vi; // OK, iterator object is mutable
    assert(*vi == 1);
    // *vi = 13; // Error: underlying element is read-only
 
    int a[]{-5, 10, 15};
    auto ai = std::ranges::crbegin(a);
    assert(*ai == 15);
 
    // auto x_x = std::ranges::crbegin(std::vector<int>{6, 6, 6});
    // ill-formed: the argument is an rvalue (see Notes ↑)
 
    auto si = std::ranges::crbegin(std::span{a}); // OK
    assert(*si == 15);
    static_assert
    (
        std::ranges::enable_borrowed_range<std::remove_cv_t<decltype(std::span{a})>>
    );
}

Siehe auch

ranges::rbegin (C++20)	gibt einen Reverse-Iterator zu einem Range zurück (Customization Point Objekt)
rbegincrbegin (C++14)	gibt einen Reverse-Iterator zum Anfang eines Containers oder Arrays zurück (function template)