std::ranges::borrowed_range, std::ranges::enable_borrowed_range

 

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>
template< class R > concept borrowed_range =     ranges::range<R> &&     (std::is_lvalue_reference_v<R> ||      ranges::enable_borrowed_range<std::remove_cvref_t<R>>);	(1)	(seit C++20)
template< class R > constexpr bool enable_borrowed_range = false;	(2)	(seit C++20)

1) Das Konzept borrowed_range definiert die Anforderungen an einen Bereich, sodass eine Funktion ihn per Wert übernehmen und daraus abgeleitete Iteratoren gefahrlos zurückgeben kann, ohne dass diese ungültig werden.

2) Das Variablen-Template enable_borrowed_range wird verwendet, um anzuzeigen, ob ein range ein borrowed_range ist. Die primäre Template ist als false definiert.

Semantische Anforderungen

Sei U std::remove_reference_t<T>, wenn T ein rvalue-Referenztyp ist, andernfalls T. Bei einer Variablen u vom Typ U modelliert T borrowed_range nur dann, wenn die Gültigkeit von von u abgeleiteten Iteratoren nicht an die Lebensdauer dieser Variablen gebunden ist.

Spezialisierungen

Ein Programm darf enable_borrowed_range für cv-unqualifizierte benutzerdefinierte Typen, die borrowed_range modellieren, zu true und für Typen, die dies nicht tun, zu false spezialisieren. Solche Spezialisierungen müssen in Konstanten Ausdrücken verwendbar sein und den Typ const bool haben.

Bedingungslos geliehene Bereiche in der Standardbibliothek

Spezialisierungen von enable_borrowed_range für alle Spezialisierungen der folgenden Standard-Templates sind als true definiert:

• std::basic_string_view
• std::span
• std::ranges::subrange
• std::ranges::ref_view
• std::ranges::empty_view
• std::ranges::iota_view

Bedingt geliehene Bereiche in der Standardbibliothek

Spezialisierungen von enable_borrowed_range für die folgenden Standard-Bereichsadapter sind genau dann als true definiert, wenn std::ranges::enable_borrowed_range<V> true ist, wobei V der zugrundeliegende View-Typ ist.

std::ranges::adjacent_view std::ranges::as_const_view std::ranges::as_rvalue_view std::ranges::chunk_view

(seit C++23)

• std::ranges::common_view
• std::ranges::drop_view
• std::ranges::drop_while_view
• std::ranges::elements_view

std::ranges::enumerate_view

(seit C++23)

• std::ranges::owning_view
• std::ranges::reverse_view

std::ranges::slide_view std::ranges::stride_view

(seit C++23)

• std::ranges::take_view

std::ranges::to_input_view

(seit C++26)

Spezialisierungen von enable_borrowed_range für die folgenden Standard-Bereichsadapter sind genau dann als true definiert, wenn (std::ranges::enable_borrowed_range<Vs> && ...) true ist, wobei Vs... alle View-Typen sind, die sie adaptieren. std::ranges::zip_view

(seit C++23)

Beispiel

Demonstriert die Spezialisierungen von enable_borrowed_range für benutzerdefinierte Typen. Solche Spezialisierungen schützen vor potenziell ungültigen Ergebnissen.

Führen Sie diesen Code aus

#include <algorithm>
#include <array>
#include <cstddef>
#include <iostream>
#include <ranges>
#include <span>
#include <type_traits>
 
template<typename T, std::size_t N>
struct MyRange : std::array<T, N> {};
 
template<typename T, std::size_t N>
constexpr bool std::ranges::enable_borrowed_range<MyRange<T, N>> = false;
 
template<typename T, std::size_t N>
struct MyBorrowedRange : std::span<T, N> {};
 
template<typename T, std::size_t N>
constexpr bool std::ranges::enable_borrowed_range<MyBorrowedRange<T, N>> = true;
 
int main()
{
    static_assert(std::ranges::range<MyRange<int, 8>>);
    static_assert(std::ranges::borrowed_range<MyRange<int, 8>> == false);
    static_assert(std::ranges::range<MyBorrowedRange<int, 8>>);
    static_assert(std::ranges::borrowed_range<MyBorrowedRange<int, 8>> == true);
 
    auto getMyRangeByValue = []{ return MyRange<int, 4>{{1, 2, 42, 3}}; };
    auto dangling_iter = std::ranges::max_element(getMyRangeByValue());
    static_assert(std::is_same_v<std::ranges::dangling, decltype(dangling_iter)>);
    // *dangling_iter; // compilation error (i.e. dangling protection works.)
 
    auto my = MyRange<int, 4>{{1, 2, 42, 3}};
    auto valid_iter = std::ranges::max_element(my);
    std::cout << *valid_iter << ' '; // OK: 42
 
    auto getMyBorrowedRangeByValue = []
    {
        static int sa[4]{1, 2, 42, 3};
        return MyBorrowedRange<int, std::size(sa)>{sa};
    };
    auto valid_iter2 = std::ranges::max_element(getMyBorrowedRangeByValue());
    std::cout << *valid_iter2 << '\n'; // OK: 42
}

Ausgabe

42 42

Siehe auch

ranges::dangling (C++20)

ein Platzhaltertyp, der anzeigt, dass ein Iterator oder ein subrange nicht zurückgegeben werden sollte, da er hängen würde (Klasse)