Namespaces
Variants

std::ranges:: dangling

From cppreference.net
C++
Ranges library
Range adaptors
Défini dans l'en-tête <ranges>
struct dangling ;
(depuis C++20)

dangling est un type d'espace réservé et un type de classe vide, utilisé conjointement avec les alias de modèles ranges::borrowed_iterator_t et ranges::borrowed_subrange_t .

Lorsque certains algorithmes contraints qui retournent habituellement un itérateur ou un sous-intervalle d'un range prennent un argument particulier de range rvalue qui ne modélise pas borrowed_range , dangling sera retourné à la place pour éviter de retourner des résultats potentiellement pendants.

Table des matières

Fonctions membres

std::ranges::dangling:: dangling

constexpr dangling ( ) noexcept = default ;
(1)
template < class ... Args >
constexpr dangling ( Args && ... ) noexcept { }
(2)
1) dangling est trivialement constructible par défaut.
2) dangling peut être construit à partir d'arguments en nombre arbitraire et de type non-void arbitraire. La construction n'a aucun effet secondaire en elle-même.

En d'autres termes, après avoir remplacé le type (par exemple un type d'itérateur) dans une initialisation non-agrégat valide par dangling , l'initialisation résultante reste valide.

Exemple

Exécuter ce code 
#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'; // erreur de compilation : pas de correspondance pour 'operator*'
                                         // (le type d'opérande est '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 modélise borrowed_range
    static_assert(!std::is_same_v<std::ranges::dangling, decltype(valid_iter2)>);
    std::cout << '\'' << *valid_iter2 << '\'' << '\n'; // 'a'
}

Sortie : 

1 'a'

Voir aussi

(C++20)
obtient le type d'itérateur ou le type subrange d'un borrowed_range
(alias de modèle)
(C++20)
spécifie qu'un type est un range et que les itérateurs obtenus à partir d'une expression de celui-ci peuvent être retournés en toute sécurité sans risque de dangling
(concept)