Namespaces
Variants

operator==,<=> (std::counted_iterator)

From cppreference.net
C++
Iterator library
Iterator concepts
Iterator primitives
Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
(C++20)
(C++20)
(C++20)
Utilities
(C++20)
Iterator adaptors
Range access
(C++11) (C++14)
(C++14) (C++14)
(C++11) (C++14)
(C++14) (C++14)
(C++17) (C++20)
(C++17)
(C++17)
std::counted_iterator
template < std:: common_with < I > I2 >

friend constexpr bool operator == (

const counted_iterator & x, const counted_iterator < I2 > & y ) ;
(1) (depuis C++20)
template < std:: common_with < I > I2 >

friend constexpr strong_ordering operator <=> (

const counted_iterator & x, const counted_iterator < I2 > & y ) ;
(2) (depuis C++20)

Compare les longueurs sous-jacentes (c'est-à-dire les distances jusqu'à la fin).

1) Vérifie si les longueurs sous-jacentes sont égales.
2) Compare les longueurs sous-jacentes avec l'opérateur <=> .

Le comportement n'est pas défini si x et y ne pointent pas vers des éléments de la même séquence. Autrement dit, il doit exister un certain n tel que std:: next ( x. base ( ) , x. count ( ) + n ) et std:: next ( y. base ( ) , y. count ( ) + n ) se réfèrent au même élément.

Les opérateurs < , <= , > , >= et != sont synthétisés respectivement à partir de operator <=> et operator == .

Ce modèle de fonction n'est pas visible par la recherche non qualifiée ou qualifiée ordinaire, et ne peut être trouvé que par la recherche dépendante des arguments lorsque std::counted_iterator<I> est une classe associée des arguments.

Table des matières

Paramètres

x, y - adaptateurs d'itérateurs

Valeur de retour

1) x. count ( ) == y. count ( )
2) y. count ( ) <=> x. count ( )

Notes

Puisque la longueur décroît, et non croît, l'ordre des arguments de operator <=> dans l'expression de comparaison sous-jacente est inversé, c'est-à-dire que y est lhs , x est rhs .

Exemple

Exécuter ce code 
#include <initializer_list>
#include <iterator>
int main()
{
    static constexpr auto v = {1, 2, 3, 4, 5, 6};
    constexpr std::counted_iterator<std::initializer_list<int>::iterator>
        it1{v.begin(), 5},
        it2{v.begin(), 5},
        it3{v.begin() + 1, 4},
        it4{v.begin(), 0};
    static_assert(it1 == it2);
    static_assert(it2 != it3);
    static_assert(it2 <  it3);
    static_assert(it1 <= it2);
    static_assert(it3 != std::default_sentinel);
    static_assert(it4 == std::default_sentinel);
//  it2 == std::counted_iterator{v.begin(), 4}; // UB: les opérandes ne font pas référence à
                                                // des éléments de la même séquence
}

Voir aussi

(C++20)
vérifie si la distance jusqu'à la fin est égale à ​0​
(modèle de fonction)
(C++20)
avance l'itérateur
(modèle de fonction)
(C++20)
calcule la distance entre deux adaptateurs d'itérateur
(modèle de fonction)