Namespaces
Variants

std::ranges:: dangling

From cppreference.net
C++
Ranges library
Range adaptors
Definido en el encabezado <ranges>
struct dangling ;
(desde C++20)

dangling es un tipo de marcador de posición y un tipo de clase vacía, utilizado junto con los alias de plantilla ranges::borrowed_iterator_t y ranges::borrowed_subrange_t .

Cuando algunos algoritmos restringidos que normalmente retornan un iterador o un subrango de un range toman un argumento particular de rvalue range que no modela borrowed_range , dangling será retornado en su lugar para evitar retornar resultados potencialmente colgantes.

Contenidos

Funciones miembro

std::ranges::dangling:: dangling

constexpr dangling ( ) noexcept = default ;
(1)
template < class ... Args >
constexpr dangling ( Args && ... ) noexcept { }
(2)
1) dangling es trivialmente construible por defecto.
2) dangling puede ser construido a partir de argumentos de número arbitrario y tipo no-void arbitrario. La construcción no tiene ningún efecto secundario por sí misma.

En otras palabras, después de reemplazar el tipo (por ejemplo, un tipo de iterador) en una inicialización no-agregada bien formada con dangling , la inicialización resultante también está bien formada.

Ejemplo

Ejecutar este código 
#include <algorithm>
#include <array>
#include <iostream>
#include <ranges>
#include <type_traits>
#include <string_view>
int main()
{
    auto get_array_by_value = [] { return std::array{0, 1, 0, 1}; };
    auto dangling_iter = std::ranges::max_element(get_array_by_value());
    static_assert(std::is_same_v<std::ranges::dangling, decltype(dangling_iter)>);
//  std::cout << *dangling_iter << '\n'; // error de compilación: no hay coincidencia para 'operator*'
                                         // (el tipo del operando es 'std::ranges::dangling')
    auto get_persistent_array = []() -> const std::array<int, 4>& {
        static constexpr std::array a{0, 1, 0, 1};
        return a;
    };
    auto valid_iter = std::ranges::max_element(get_persistent_array());
    static_assert(!std::is_same_v<std::ranges::dangling, decltype(valid_iter)>);
    std::cout << *valid_iter << ' '; // 1
    auto get_string_view = [] { return std::string_view{"alpha"}; };
    auto valid_iter2 = std::ranges::min_element(get_string_view());
        // OK: std::basic_string_view modela borrowed_range
    static_assert(!std::is_same_v<std::ranges::dangling, decltype(valid_iter2)>);
    std::cout << '\'' << *valid_iter2 << '\'' << '\n'; // 'a'
}

Salida: 

1 'a'

Véase también

(C++20)
obtiene el tipo de iterador o tipo subrange de un borrowed_range
(alias de plantilla)
(C++20)
especifica que un tipo es un range y los iteradores obtenidos de una expresión del mismo pueden devolverse de forma segura sin peligro de referencias colgantes
(concepto)