operator==,!=,<,<=,>,>=,<=>(std::vector) - cppreference.com

De cppreference.com

</tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody>

Definido en el archivo de encabezado `<...>`
	(1)
`template< class T, class Alloc > bool operator==( const std::vector<T, Alloc>& lhs, const std::vector<T, Alloc>& rhs );`			(hasta C++20)
`template< class T, class Alloc > constexpr bool operator==( const std::vector<T, Alloc>& lhs, const std::vector<T, Alloc>& rhs );`			(desde C++20)
`template< class T, class Alloc > bool operator!=( const std::vector<T, Alloc>& lhs, const std::vector<T, Alloc>& rhs );`		(2)	(hasta C++20)
`template< class T, class Alloc > bool operator<( const std::vector<T, Alloc>& lhs, const std::vector<T, Alloc>& rhs );`		(3)	(hasta C++20)
`template< class T, class Alloc > bool operator<=( const std::vector<T, Alloc>& lhs, const std::vector<T, Alloc>& rhs );`		(4)	(hasta C++20)
`template< class T, class Alloc > bool operator>( const std::vector<T, Alloc>& lhs, const std::vector<T, Alloc>& rhs );`		(5)	(hasta C++20)
`template< class T, class Alloc > bool operator>=( const std::vector<T, Alloc>& lhs, const std::vector<T, Alloc>& rhs );`		(6)	(hasta C++20)
`template< class T, class Alloc > constexpr /* véase más abajo */ operator<=>( const std::vector<T, Alloc>& lhs, const std::vector<T, Alloc>& rhs );`		(7)	(desde C++20)

Compara el contenido de dos objetos vector.

1-2) Comprueba el contenido de lhs y rhs es igual; es decir, tienen el mismo número de elementos y cada elemento en lhs se compara igual con el elemento en rhs en la misma posición.

3-6) Compara el contenido de lhs y rhs léxicográficamente. La comparación se realiza por una función equivalente a std::lexicographical_compare.

7) Compara el contenido de lhs y rhs léxicográficamente. La comparación se realiza como si se llamara a std::lexicographical_compare_three_way en dos objetos vector con un objeto función realizando la comparación de tres vías sintetizada (véase más abajo). El tipo de retorno es el mismo que el tipo del resultado de la comparación de tres vías sintetizada.

Dados dos l-valores const E, lhs y rhs como los operadores del lado izquierdo y del lado derecho, respectivamente (donde E es T), la comparación de tres vías sintetizada se define como:

si std::three_way_comparable_with<E, E> se satisface, es equivalente a lhs <=> rhs;
de lo contrario, si comparar dos l-valores const E por el operator< está bien formado y el tipo del resultado satisface a boolean-testable, es equivalente a

lhs < rhs ? std::weak_ordering::less :
rhs < lhs ? std::weak_ordering::greater :
            std::weak_ordering::equivalent

de lo contrario, la comparación de tres vías sintetizada no se define, y operator<=> no participa en la resolución de sobrecarga.

El comportamiento de operator<=> está indefinido si three_way_comparable_with o boolean-testable se satisface pero no se modela, u operator< se utiliza pero E y < no establecen un orden total.

Parámetros

lhs, rhs	-	Objetos `vector` cuyo contenido hay que comparar.
-`T` debe satisfacer los requisitos de EqualityComparable para poder usar las sobrecargas (1-2).
-`T` debe satisfacer los requisitos de LessThanComparable para poder usar las sobrecargas (3-6). La relación de orden debe establecer un orden total.

Valor de retorno

1) true el contenido de los objetos vector son iguales; de lo contrario, false.

2) true el contenido de los objetos vector no son iguales; de lo contrario, false.

3) true el contenido de los/las lhs es léxicográficamente menor que el contenido de rhs; de lo contrario, false.

4) true el contenido de los/las lhs es léxicográficamente menor que o igual que el contenido de rhs; de lo contrario, false.

5) true el contenido de los/las lhs es léxicográficamente mayor que el contenido de rhs; de lo contrario, false.

6) true el contenido de los/las lhs es léxicográficamente mayor que o igual que el contenido de rhs; de lo contrario, false.

7) El orden relativo del primer par de elementos no equivalentes en lhs y rhs, si existen tales elementos; de lo contrario, lhs.size() <=> rhs.size().

Complejidad

1-2) Constante si lhs y rhs son de diferente tamaño; de lo contrario, lineal de acuerdo al tamaño del vector.

3-7) Lineal de acuerdo al tamaño del vector.

Ejemplo

#include <algorithm>
#include <iostream>
#include <...>
 
int main()
{
    std::vector<int> alice{1, 2, 3};
    std::vector<int> bob{7, 8, 9, 10};
    std::vector<int> eve{1, 2, 3};

    std::cout << std::boolalpha;

    // Comparar dos contenedores desiguales
    std::cout << "alice == bob devuelve " << (alice == bob) << '\n';
    std::cout << "alice != bob devuelve " << (alice != bob) << '\n';
    std::cout << "alice <  bob devuelve " << (alice < bob) << '\n';
    std::cout << "alice <= bob devuelve " << (alice <= bob) << '\n';
    std::cout << "alice >  bob devuelve " << (alice > bob) << '\n';
    std::cout << "alice >= bob devuelve " << (alice >= bob) << '\n';

    std::cout << '\n';

    // Comparar dos contenedores desiguales
    std::cout << "alice == eve devuelve " << (alice == eve) << '\n';
    std::cout << "alice != eve devuelve " << (alice != eve) << '\n';
    std::cout << "alice <  eve devuelve " << (alice < eve) << '\n';
    std::cout << "alice <= eve devuelve " << (alice <= eve) << '\n';
    std::cout << "alice >  eve devuelve " << (alice > eve) << '\n';
    std::cout << "alice >= eve devuelve " << (alice >= eve) << '\n';
}

Salida:

alice == bob devuelve false
alice != bob devuelve true
alice <  bob devuelve true
alice <= bob devuelve true
alice >  bob devuelve false
alice >= bob devuelve false

alice == eve devuelve true
alice != eve devuelve false
alice <  eve devuelve false
alice <= eve devuelve true
alice >  eve devuelve false
alice >= eve devuelve true