std::ranges::borrowed_range, std::ranges::enable_borrowed_range
<ranges>
concept borrowed_range =
ranges::range <R> &&
(std::is_lvalue_reference_v <R> ||
constexpr bool enable_borrowed_range = false;
borrowed_range defines the requirements of a range such that a function can take it by value and return iterators obtained from it without danger of dangling.enable_borrowed_range variable template is used to indicate whether a range is a borrowed_range. The primary template is defined as false.Contents
[edit] Semantic requirements
Let U be std::remove_reference_t <T> if T is an rvalue reference type, and T otherwise. Given a variable u of type U, T models borrowed_range only if the validity of iterators obtained from u is not tied to the lifetime of that variable.
[edit] Specializations
A program may specialize enable_borrowed_range to true for cv-unqualified program-defined types which model borrowed_range, and false for types which do not. Such specializations shall be usable in constant expression and have type const bool.
[edit] Unconditionally borrowed ranges in the standard library
Specializations of enable_borrowed_range for all specializations of the following standard templates are defined as true:
- std::basic_string_view
- std::span
- std::ranges::subrange
- std::ranges::ref_view
- std::ranges::empty_view
- std::ranges::iota_view
[edit] Conditionally borrowed ranges in the standard library
Specialization of enable_borrowed_range for the following standard range adaptors are defined as true if and only if std::ranges::enable_borrowed_range<V> is true, where V is the underlying view type:
- std::ranges::adjacent_view
- std::ranges::as_const_view
- std::ranges::as_rvalue_view
- std::ranges::chunk_view [1]
- std::ranges::common_view
- std::ranges::drop_view
- std::ranges::drop_while_view
- std::ranges::elements_view
- ↑ The underlying view
Vmust also satisfyforward_range.
Specialization of enable_borrowed_range for the following standard range adaptors are defined as true if and only if (std::ranges::enable_borrowed_range<Vs> && ...) is true, where Vs... are all view types it adapts:
[edit] Example
Demonstrates the specializations of enable_borrowed_range for program defined types. Such specializations protect against potentially dangling results.
#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 }
Output:
42 42
[edit] See also
subrange should not be returned since it would be dangling (class) [edit]