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

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de contenedores

De secuencias

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

deque

forward_list (C++11)

list

Asociativos

set

multiset

map

multimap

Asociativos no ordenados

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptadores

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Vistas

span (C++20)

mdspan (C++23)

Tablas

Invalidación de iteradores

Tabla de funciones miembro

Tabla de funciones no miembro

 

std::inplace_vector

Tipos miembro
Funciones miembro
inplace_vector::inplace_vector inplace_vector::~inplace_vector    inplace_vector::operator= inplace_vector::assign inplace_vector::assign_range Tamaño y capacidad inplace_vector::empty inplace_vector::size inplace_vector::max_size inplace_vector::capacity inplace_vector::resize inplace_vector::reserve inplace_vector::shrink_to_fit Iteradores inplace_vector::begininplace_vector::cbegin inplace_vector::endinplace_vector::cend inplace_vector::rbegininplace_vector::crbegin inplace_vector::rendinplace_vector::crend	Acceso a elementos inplace_vector::at inplace_vector::operator[] inplace_vector::front inplace_vector::back inplace_vector::data Modificadores inplace_vector::clear inplace_vector::erase inplace_vector::swap inplace_vector::insert inplace_vector::insert_range inplace_vector::emplace inplace_vector::emplace_back inplace_vector::try_emplace_back inplace_vector::unchecked_emplace_back inplace_vector::push_back inplace_vector::try_push_back inplace_vector::unchecked_push_back inplace_vector::pop_back inplace_vector::append_range inplace_vector::try_append_range
Funciones no miembro
erase(std::inplace_vector)erase_if(std::inplace_vector) swap(std::inplace_vector)	operator==operator<=>

 

<tbody> </tbody>

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)

See More

Compara el contenido de dos objetos de tipo std::inplace_vector.

1) Comprueba si el contenido de lhs y rhs es igual, es decir, tienen la misma cantidad de elementos y cada elemento de lhs es igual al elemento de rhs en la misma posición.

2) Compara el contenido 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>).

Se debe cumplir al menos una de las siguientes condiciones:

• T modela three_way_comparable.
• < se define para valores de tipo (posiblemente calificados como constantes) T, y < es una relación de ordenación total.

   De lo contrario, el comportamiento no está definido.

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

Parámetros

lhs, rhs	-	Los objetos std::inplace_vector cuyo contenido hay que comparar.
- T debe satisfacer los requisitos de ComparableEnIgualdad para poder usar las sobrecargas (1).

Valor de retorno

1) true si el contenido de los objetos std::inplace_vector 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 son de diferente tamaño, en caso contrario lineal en el tamaño de std::inplace_vector.

2) Lineal en el tamaño de 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.

En particular, 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

Ejecuta este código

#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
    (""
        "Comparar contenedores iguales:" &&
        (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 &&

        "Comparar contenedores desiguales:" &&
        (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 &&
    "");
}