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) (desde C++20)
template < std:: common_with < I > I2 >

friend constexpr strong_ordering operator <=> (

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

Compara las longitudes subyacentes (es decir, distancias hasta el final).

1) Verifica si las longitudes subyacentes son iguales.
2) Compara las longitudes subyacentes con el operador <=> .

El comportamiento es indefinido si x y y no apuntan a elementos de la misma secuencia. Es decir, debe existir algún n tal que std:: next ( x. base ( ) , x. count ( ) + n ) y std:: next ( y. base ( ) , y. count ( ) + n ) se refieran al mismo elemento.

Los operadores < , <= , > , >= y != se sintetizan a partir de operator <=> y operator == respectivamente.

Esta plantilla de función no es visible para la búsqueda unqualified o qualified lookup ordinaria, y solo puede ser encontrada mediante argument-dependent lookup cuando std::counted_iterator<I> es una clase asociada de los argumentos.

Contenidos

Parámetros

x, y - adaptadores de iteradores

Valor de retorno

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

Notas

Dado que el length decrece, no aumenta, el orden de los argumentos de operator <=> en la expresión de comparación subyacente está invertido, es decir, y es lhs , x es rhs .

Ejemplo

Ejecutar este código 
#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}; // Comportamiento indefinido: los operandos no se refieren a
                                                // elementos de la misma secuencia
}

Véase también

(C++20)
verifica si la distancia al final es igual a ​0​
(plantilla de función)
(C++20)
avanza el iterador
(plantilla de función)
(C++20)
calcula la distancia entre dos adaptadores de iterador
(plantilla de función)