operator==,!=(std::unordered_multimap)

 

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::unordered_multimap

Funciones miembro

unordered_multimap::unordered_multimap

unordered_multimap::~unordered_multimap

unordered_multimap::operator=

unordered_multimap::get_allocator

Iteradores

unordered_multimap::beginunordered_multimap::cbegin

unordered_multimap::endunordered_multimap::cend

Capacidad

unordered_multimap::empty

unordered_multimap::size

unordered_multimap::max_size

Modificadores

unordered_multimap::clear

unordered_multimap::insert

unordered_multimap::emplace

unordered_multimap::emplace_hint

unordered_multimap::erase

unordered_multimap::swap

unordered_multimap::extract (C++17)

unordered_multimap::merge (C++17)

Búsqueda

unordered_multimap::count

unordered_multimap::find

unordered_multimap::contains (C++20)

unordered_multimap::equal_range

Interfaz de depósito

unordered_multimap::begin(size_type)unordered_multimap::cbegin(size_type)

unordered_multimap::end(size_type)unordered_multimap::cend(size_type)

unordered_multimap::bucket_count

unordered_multimap::max_bucket_count

unordered_multimap::bucket_size

unordered_multimap::bucket

Política de dispersión

unordered_multimap::load_factor

unordered_multimap::max_load_factor

unordered_multimap::rehash

unordered_multimap::reserve

Observadores

unordered_multimap::hash_function

unordered_multimap::key_eq

Funciones no miembro

operator==operator!= (hasta C++20)

std::swap

erase_if (C++20)

Guías de deducción(C++17)

 

template<class Key, class T, class Hash, class KeyEqual, class Alloc > bool operator==(conststd::unordered_multimap<Key, T, Hash, KeyEqual, Alloc>& lhs,                  conststd::unordered_multimap<Key, T, Hash, KeyEqual, Alloc>& rhs );	(1)
template<class Key, class T, class Hash, class KeyEqual, class Alloc > bool operator!=(conststd::unordered_multimap<Key, T, Hash, KeyEqual, Alloc>& lhs,                  conststd::unordered_multimap<Key, T, Hash, KeyEqual, Alloc>& rhs );	(2)	(hasta C++20)

Compara el contenido de dos contenedores no ordenados.

El contenido de dos contenedores no ordenados lhs y rhs es igual si se mantienen las siguientes condiciones:

• lhs.size()== rhs.size();
• cada grupo de elementos equivalentes [lhs_eq1, lhs_eq2) obtenido de lhs.equal_range(lhs_eq1) tiene un grupo correspondiente de elementos equivalentes en el otro contenedor [rhs_eq1, rhs_eq2) obtenido de rhs.equal_range(rhs_eq1), que tiene las siguientes propiedades:

• std::distance(lhs_eq1, lhs_eq2)==std::distance(rhs_eq1, rhs_eq2).
• std::is_permutation(lhs_eq1, lhs_eq2, rhs_eq1)==true.

El comportamiento no está definido si Key o T no son EqualityComparable.

El comportamiento tampoco está definido si hash_function() y key_eq() no tienen(hasta C++20)key_eq() no tiene(desde C++20) el mismo comportamiento sobre lhs y rhs o si operator== para Key no es un refinamiento de la partición en grupos de claves equivalentes introducidos por key_eq() (es decir, si dos elementos que se comparan iguales usando operator== caen en distintas particiones).

El operador != se sintetiza a partir de operator==.

(desde C++20)

Parámetros

lhs, rhs

-

Los contenedores no ordenados a comparar.

Valor de retorno

1)true si el contenido de los contenedores es igual, false de lo contrario.

2)true si el contenido de los contenedores no es igual, false de lo contrario.

Complejidad

Proporcional a ΣS_i² llamadas a operator== sobre value_type, llamadas al predicado devuelto por key_eq, y llamadas a la función de dispersión devuelta por hash_function, en el caso promedio, donde S es el tamaño del i-ésimo grupo de claves equivalentes. Proporcional a N² en el peor de los casos, donde N es el tamaño del contenedor. El caso promedio se vuelve proporcional a N si los elementos dentro de cada grupo de claves equivalentes se arreglan en el mismo orden (sucede cuando los contenedores son copias uno del otro).