Namespaces
Variants

    std::ranges::iota_view<W, Bound>::iota_view

    Depuis fr.cppreference.net
     
    C++
    Support du compilateur
    Freestanding 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 de langage
    Bibliothèque de concepts (C++20)
    Bibliothèque de diagnostics
    Bibliothèque de gestion de 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 Ranges (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 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 Ranges
    Adaptateurs de ranges
     
    std::ranges::iota_view
    Fonctions membres
    Guides de déduction
    Classes imbriquées
    Itérateur
    Concepts d'aide
    Types membres
    Fonctions membres
    Fonctions non membres
    Sentinelle
    Fonctions membres
    Fonctions non membres
     
    iota_view() requires std::default_initializable<W> = default;
    		(1) (depuis C++20) 
    constexpr explicit iota_view( W value );
    		(2) (depuis C++20) 
    constexpr explicit iota_view( std::type_identity_t<W> value,
                              std::type_identity_t<Bound> bound );
    		(3) (depuis C++20) 
    constexpr explicit iota_view( /*iterator*/ first, /* see below */ last );
    		(4) (depuis C++20)

    Construit un iota_view.

    1) Constructeur par défaut. Initialise par valeur le value_ sous-jacent et bound_.
    2) Initialise value_ avec value et initialise par valeur bound_.
    • Le comportement est indéfini si :
    • Bound n'est pas std::unreachable_sentinel_t et que Bound() n'est pas atteignable depuis value.
    • std::totally_ordered_with<W, Bound> est modélisé, et bool(value <= Bound()) est false.
    3) Initialise value_ avec value et bound_ avec bound.
    • Le comportement est indéfini si :
    • Bound n'est pas std::unreachable_sentinel_t et que bound n'est pas atteignable depuis value.
    • std::totally_ordered_with<W, Bound> est modélisé, et bool(value <= bound) est false.
    4) Initialise value_ avec la valeur W stockée dans first, et initialise bound_ avec la valeur Bound représentée par last (qui a le même type que celui de end()).
    • si W et Bound sont du même type, équivalent à iota_view(first.value_, last.value_).
    • Sinon, si Bound est std::unreachable_sentinel_t, équivalent à iota_view(first.value_, last).
    • Sinon, équivalent à iota_view(first.value_, last.bound_).

    Paramètres

    value - la valeur de départ
    bound - la limite
    first - l'itérateur indiquant la valeur de départ
    last - l'itérateur ou sentinelle indiquant la limite

    Exemple

    Exécuter ce code 
    #include <cassert>
#include <iostream>
#include <iterator>
#include <ranges>
int main()
{
    const auto l = {1, 2, 3, 4};
    auto i1 = std::ranges::iota_view<int, int>(); // surcharge (1)
    assert(i1.empty() and i1.size() == 0);
    auto i2 = std::ranges::iota_view(1); // surcharge (2)
    assert(not i2.empty() and i2.front() == 1);
    for (std::cout << "1) "; auto e : i2 | std::views::take(3))
        std::cout << e << ' ';
    std::cout << '\n';
    auto i3 = std::ranges::iota_view(std::begin(l)); // surcharge (2)
    assert(not i3.empty() and i3.front() == l.begin());
    for (std::cout << "2) "; auto e : i3 | std::views::take(4))
        std::cout << *e << ' ';
    std::cout << '\n';
    auto i4 = std::ranges::iota_view(1, 8); // surcharge (3)
    assert(not i4.empty() and i4.front() == 1 and i4.back() == 7);
    for (std::cout << "3) "; auto e : i4)
        std::cout << e << ' ';
    std::cout << '\n';
    auto i5 = std::ranges::iota_view(l.begin(), l.end()); // surcharge (4)
    for (std::cout << "4) "; auto e : i5)
        std::cout << *e << ' ';
    std::cout << '\n';
    auto i6 = std::ranges::iota_view(l.begin(), std::unreachable_sentinel); // (4)
    for (std::cout << "5) "; auto e : i6 | std::views::take(3))
        std::cout << *e << ' ';
    std::cout << '\n';
}

    Sortie : 

    1) 1 2 3
2) 1 2 3 4
3) 1 2 3 4 5 6 7
4) 1 2 3 4
5) 1 2 3

    Rapports de défauts

    Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

    DR Appliqué à Comportement publié Comportement corrigé
    LWG 3523 C++20 la surcharge (4) pouvait utiliser un type de sentinelle incorrect corrigé
    P2711R1 C++20 les surcharges (3,4) n'étaient pas explicites rendues explicites