Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
Definido en el encabezado <ranges>
template < class R >

concepto borrowed_range =
ranges:: range < R > &&
( std:: is_lvalue_reference_v < R > ||

ranges :: enable_borrowed_range < std:: remove_cvref_t < R >> ) ;
(1) (desde C++20)
template < class R >
constexpr bool enable_borrowed_range = false ;
(2) (desde C++20)
1) El concepto borrowed_range define los requisitos de un rango tal que una función puede tomarlo por valor y devolver iteradores obtenidos de él sin peligro de referencias colgantes.
2) La enable_borrowed_range plantilla de variable se utiliza para indicar si un range es un borrowed_range . La plantilla principal se define como false .

Contenidos

Requisitos semánticos

Sea U igual a std:: remove_reference_t < T > si T es un tipo de referencia a valor-R (rvalue), y T en caso contrario. Dada una variable u de tipo U , T modela borrowed_range solo si la validez de los iteradores obtenidos de u no está vinculada al tiempo de vida de dicha variable.

Especializaciones

Un programa puede especializar enable_borrowed_range a true para tipos definidos por el programa sin calificación cv que modelen borrowed_range , y a false para tipos que no lo hagan. Dichas especializaciones deberán ser utilizables en expresiones constantes y tener tipo const bool .

Rangos prestados incondicionalmente en la biblioteca estándar

Especializaciones de enable_borrowed_range para todas las especializaciones de las siguientes plantillas estándar se definen como true :

Rangos condicionalmente prestados en la biblioteca estándar

Especialización de enable_borrowed_range para los siguientes adaptadores de rango estándar se define como true si y solo si std :: ranges :: enable_borrowed_range < V > es true , donde V es el tipo de vista subyacente:

(desde C++23)
(desde C++23)
(desde C++23)
(desde C++26)
  1. ↑ La vista subyacente V también debe satisfacer forward_range .

Las especializaciones de enable_borrowed_range para los siguientes adaptadores de rango estándar se definen como true si y solo si ( std :: ranges :: enable_borrowed_range < Vs > && ... ) es true , donde Vs... son todos los tipos de vista que adapta:

(desde C++23)

Ejemplo

Demuestra las especializaciones de enable_borrowed_range para tipos definidos por el programa. Tales especializaciones protegen contra resultados potencialmente colgantes.

Ejecutar este código 
#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
}

Salida: 

42 42

Véase también

(C++20)
un tipo marcador de posición que indica que un iterador o un subrange no debería ser devuelto ya que quedaría colgante
(clase)