Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
Definiert im Header <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 eines Ranges, sodass eine Funktion ihn als Wert übernehmen und von ihm erhaltene Iteratoren zurückgeben kann, ohne Gefahr von Dangling-Zeigern.
2) Die enable_borrowed_range Variable Template wird verwendet, um anzuzeigen, ob ein range ein borrowed_range ist. Das primäre Template ist als false definiert.

Inhaltsverzeichnis

Semantische Anforderungen

Sei U gleich std:: remove_reference_t < T > falls T ein Rvalue-Referenztyp ist, andernfalls gleich T . Für eine Variable u vom Typ U modelliert T borrowed_range nur dann, wenn die Gültigkeit der von u erhaltenen Iteratoren nicht an die Lebensdauer dieser Variable gebunden ist.

Spezialisierungen

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

Unbedingt entliehene Ranges in der Standardbibliothek

Spezialisierungen von enable_borrowed_range für alle Spezialisierungen der folgenden Standardtemplates sind als true definiert:

*Hinweis: Da alle Textinhalte innerhalb der ` `-Tags C++-spezifische Begriffe sind und gemäß den Anweisungen nicht übersetzt werden dürfen, bleibt der gesamte Inhalt unverändert. Die HTML-Struktur und Attribute wurden gemäß den Vorgaben beibehalten.*

Bedingt entlehnte Ranges in der Standardbibliothek

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

(seit C++23)
(seit C++23)
(seit C++23)
(seit C++26)
  1. ↑ Die zugrunde liegende Ansicht V muss ebenfalls forward_range erfüllen.

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

(seit C++23)

Beispiel

Demonstriert die Spezialisierungen von enable_borrowed_range für programmdefinierte Typen. Solche Spezialisierungen schützen vor potenziell hängenden Ergebnissen.

Diesen Code ausführen 
#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; // Kompilierungsfehler (d.h. Schutz vor hängenden Zeigern funktioniert.)
    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

(C++20)
Ein Platzhaltertyp, der anzeigt, dass ein Iterator oder ein subrange nicht zurückgegeben werden sollte, da er verwaist wäre
(Klasse)