Namespaces
Variants

    std::ranges::dangling

    Von de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    (C++23)
     
    Definiert in Header <ranges> 
    struct dangling;
    		(seit C++20)

    dangling ist ein Platzhaltertyp und ein leerer Klassentyp, der zusammen mit den Typaliasen ranges::borrowed_iterator_t und ranges::borrowed_subrange_t verwendet wird.

    Wenn einige eingeschränkte Algorithmen, die normalerweise einen Iterator oder einen Teilbereich eines Bereichs zurückgeben, ein bestimmtes rvalue-rangeArgument erhalten, das nicht das Modell borrowed_range erfüllt, wird stattdessen dangling zurückgegeben, um potenziell baumelnde Ergebnisse zu vermeiden.

    Memberfunktionen

    std::ranges::dangling:: dangling

    constexpr dangling ( ) noexcept = default ;
    		(1)
    template < class ... Args >
    constexpr dangling ( Args && ... ) noexcept { }
    		(2)
    1) dangling ist trivial standardkonstruierbar.
    2) dangling kann mit beliebig vielen Argumenten beliebiger Nicht-Void-Typen konstruiert werden. Die Konstruktion selbst hat keine Seiteneffekte.

    Mit anderen Worten: Nach dem Ersetzen des Typs (z.B. eines Iteratortyps) in einer wohlgeformten Nicht-Aggregat-Initialisierung durch dangling ist die resultierende Initialisierung ebenfalls wohlgeformt.

    Beispiel

    Diesen Code ausführen 
    #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'; // Kompilierungsfehler: keine Übereinstimmung für 'operator*'
                                         // (Operandentyp ist '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 modelliert borrowed_range
    static_assert(!std::is_same_v<std::ranges::dangling, decltype(valid_iter2)>);
    std::cout << '\'' << *valid_iter2 << '\'' << '\n'; // 'a'
}

    Ausgabe: 

    1 'a'

    Siehe auch

    (C++20)
    		Ermittelt den Iteratortyp oder subrange -Typ eines borrowed_range
    (Alias-Template)
    (C++20)
    		Spezifiziert, dass ein Typ ein range ist und Iteratoren, die von einem Ausdruck dieses Typs erhalten werden, sicher zurückgegeben werden können, ohne Gefahr von Dangling-Iteratoren
    (Konzept)