Namespaces
Variants

    std::ranges::dangling

    Depuis fr.cppreference.net
     
    C++
    Support du compilateur
    Indépendant et hébergé
    Langage
    Bibliothèque standard
    En-têtes de la bibliothèque standard
    Exigences nommées
    Macros de test de fonctionnalités (C++20)
    Bibliothèque de support du langage
    Bibliothèque de concepts (C++20)
    Bibliothèque de diagnostics
    Bibliothèque de gestion de la mémoire
    Bibliothèque de métaprogrammation (C++11)
    Bibliothèque d'utilitaires généraux
    Bibliothèque de conteneurs
    Bibliothèque d'itérateurs
    Bibliothèque de plages (C++20)
    Bibliothèque d'algorithmes
    Bibliothèque de chaînes
    Bibliothèque de traitement de texte
    Bibliothèque numérique
    Bibliothèque de date et heure
    Bibliothèque d'entrée/sortie
    Bibliothèque de système de fichiers (C++17)
    Bibliothèque de support de la concurrence (C++11)
    Bibliothèque de contrôle d'exécution (C++26)
    Spécifications techniques
    Index des symboles
    Bibliothèques externes
     
    Bibliothèque de plages
    Adaptateurs de plage
     
    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é avec les alias de modèle ranges::borrowed_iterator_t et ranges::borrowed_subrange_t.

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

    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)