Namespaces
Variants

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

De es.cppreference.net
 
 
 
 
constexpr friend bool operator==( const std::inplace_vector<T, N>& lhs,
                                  const std::inplace_vector<T, N>& rhs );
(1) (desde C++26)
constexpr friend synth-three-way-result<T>
    operator<=>( const std::inplace_vector<T, N>& lhs,
                 const std::inplace_vector<T, N>& rhs );
(2) (desde C++26)

Compara los contenidos de dos std::inplace_vectors.

1) Comprueba si los contenidos de lhs y rhs son iguales, 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.
2) Compara los contenidos de lhs y rhs lexicográficamente. La comparación se realiza como si se llamara a
std::lexicographical_compare_three_way(lhs.begin(), lhs.end(),
                                       rhs.begin(), rhs.end(), /*synth-three-way*/);
El tipo de retorno es el tipo de retorno de synth-three-way (es decir, synth-three-way-result <T>).
Debe cumplirse al menos una de las siguientes condiciones:
  • T models three_way_comparable.
  • < está definido para valores de tipo (posiblemente calificado como const) T, y < es una relación de orden total.
   De lo contrario, el comportamiento no está definido.

Los operadores <, <=, >, >= y != son sintetizados de operator<=> y operator== respectivamente.

Parámetros

lhs, rhs - std::inplace_vector s cuyos contenidos comparar
-
T debe cumplir con los requisitos de EqualityComparable para utilizar las sobrecargas (1).

Valor de retorno

1) true si los contenidos de los std::inplace_vector s son iguales, false en caso contrario.
2) El orden relativo del primer par de elementos no equivalentes en lhs y rhs si existen tales elementos, lhs. size ( ) <=> rhs. size ( ) en caso contrario.

Complejidad

1) Constante si lhs y rhs tienen tamaños diferentes, de lo contrario lineal con respecto al tamaño del std::inplace_vector .
2) Lineal en el tamaño del std::inplace_vector .

Notas

Los operadores relacionales se definen en términos de synth-three-way , que utiliza operator <=> si es posible, o operator < en caso contrario.

Cabe destacar que, si el elemento no proporciona por sí mismo operator <=> , pero es convertible implícitamente a un tipo comparable de tres vías, se utilizará esa conversión en lugar de operator < .

Ejemplo

#include <inplace_vector>

int main()
{
    constexpr std::inplace_vector<int, 4>
        a{1, 2, 3},
        b{1, 2, 3},
        c{7, 8, 9, 10};

    static_assert
    (""
        "Compare equal containers:" &&
        (a != b) == false &&
        (a == b) == true &&
        (a < b) == false &&
        (a <= b) == true &&
        (a > b) == false &&
        (a >= b) == true &&
        (a <=> b) >= 0 &&
        (a <=> b) <= 0 &&
        (a <=> b) == 0 &&

        "Compare non equal containers:" &&
        (a != c) == true &&
        (a == c) == false &&
        (a < c) == true &&
        (a <= c) == true &&
        (a > c) == false &&
        (a >= c) == false &&
        (a <=> c) < 0 &&
        (a <=> c) != 0 &&
        (a <=> c) <= 0 &&
    "");
}