Namespaces
Variants

operator==,!=,<,<=,>,>=,<=> (std::reverse_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::reverse_iterator
Definido en el encabezado <iterator>
template < class Iter1, class Iter2 >

bool operator == ( const std:: reverse_iterator < Iter1 > & lhs,

const std:: reverse_iterator < Iter2 > & rhs ) ;
(1) (constexpr desde C++17)
template < class Iter1, class Iter2 >

bool operator ! = ( const std:: reverse_iterator < Iter1 > & lhs,

const std:: reverse_iterator < Iter2 > & rhs ) ;
(2) (constexpr desde C++17)
template < class Iter1, class Iter2 >

bool operator < ( const std:: reverse_iterator < Iter1 > & lhs,

const std:: reverse_iterator < Iter2 > & rhs ) ;
(3) (constexpr desde C++17)
template < class Iter1, class Iter2 >

bool operator <= ( const std:: reverse_iterator < Iter1 > & lhs,

const std:: reverse_iterator < Iter2 > & rhs ) ;
(4) (constexpr desde C++17)
template < class Iter1, class Iter2 >

bool operator > ( const std:: reverse_iterator < Iter1 > & lhs,

const std:: reverse_iterator < Iter2 > & rhs ) ;
(5) (constexpr desde C++17)
template < class Iter1, class Iter2 >

bool operator >= ( const std:: reverse_iterator < Iter1 > & lhs,

const std:: reverse_iterator < Iter2 > & rhs ) ;
(6) (constexpr desde C++17)
template < class Iter1, std:: three_way_comparable_with < Iter1 > Iter2 >

constexpr std:: compare_three_way_result_t < Iter1, Iter2 >
operador <=> ( const std:: reverse_iterator < Iter1 > & lhs,

const std:: reverse_iterator < Iter2 > & rhs ) ;
(7) (desde C++20)

Compara los iteradores subyacentes de lhs y rhs .

  • Los resultados de las comparaciones de igualdad se conservan (es decir, iteradores subyacentes iguales implican iteradores inversos iguales).
  • Los resultados de las comparaciones relacionales se invierten (es decir, un iterador subyacente mayor implica un iterador inverso menor).
1) Esta sobrecarga participa en la resolución de sobrecarga solo si lhs. base ( ) == rhs. base ( ) está bien formado y es convertible a bool .
2) Esta sobrecarga participa en la resolución de sobrecarga solo si lhs. base ( ) ! = rhs. base ( ) está bien formado y es convertible a bool .
3) Esta sobrecarga participa en la resolución de sobrecarga solo si lhs. base ( ) > rhs. base ( ) está bien formado y es convertible a bool .
4) Esta sobrecarga participa en la resolución de sobrecarga solo si lhs. base ( ) >= rhs. base ( ) está bien formado y es convertible a bool .
5) Esta sobrecarga participa en la resolución de sobrecarga solo si lhs. base ( ) < rhs. base ( ) está bien formado y es convertible a bool .
6) Esta sobrecarga participa en la resolución de sobrecarga solo si lhs. base ( ) <= rhs. base ( ) está bien formado y es convertible a bool .
(desde C++20)


Contenidos

Parámetros

lhs, rhs - adaptadores de iterador para comparar

Valor de retorno

1) lhs. base ( ) == rhs. base ( )
2) lhs. base ( ) ! = rhs. base ( )
3) lhs. base ( ) > rhs. base ( )
4) lhs. base ( ) >= rhs. base ( )
5) lhs. base ( ) < rhs. base ( )
6) lhs. base ( ) <= rhs. base ( )
7) rhs. base ( ) <=> lhs. base ( )

Notas

operator <=> devuelve rhs. base ( ) <=> lhs. base ( ) en lugar de lhs. base ( ) <=> rhs. base ( ) porque este es un iterador inverso.

Ejemplo

Ejecutar este código 
#include <cassert>
#include <iterator>
int main()
{
    int a[]{0, 1, 2, 3};
    //            ↑  └───── x, y
    //            └──────── z
    // “x” e “y” son iguales, pero “x” es menor que “z” (inversamente)
    std::reverse_iterator<int*>
        x{std::rend(a) - std::size(a)},
        y{std::rend(a) - std::size(a)},
        z{std::rbegin(a) + 1};
    // comparaciones bidireccionales
    assert(  x == y );
    assert(!(x != y));
    assert(!(x <  y));
    assert(  x <= y );
    assert(!(x == z));
    assert(  x != z );
    assert(  x <  z );
    assert(  x <= z );
    // comparaciones de tres vías
    assert(  x <=> y == 0 );
    assert(!(x <=> y <  0));
    assert(!(x <=> y >  0));
    assert(!(x <=> z == 0));
    assert(  x <=> z <  0 );
    assert(!(x <=> z >  0));
}

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Applied to Behavior as published Correct behavior
LWG 280 C++98 heterogeneous assignment was not allowed allowed