Namespaces
Variants

std::unordered_map<Key,T,Hash,KeyEqual,Allocator>:: insert_or_assign

From cppreference.net

C++
Containers library
std::unordered_map
Member types
Member functions
Non-member functions
Deduction guides (C++17)
template < class M >
std:: pair < iterator, bool > insert_or_assign ( const Key & k, M && obj ) ;
(1) (desde C++17)
template < class M >
std:: pair < iterator, bool > insert_or_assign ( Key && k, M && obj ) ;
(2) (desde C++17)
template < class K, class M >
std:: pair < iterator, bool > insert_or_assign ( K && k, M && obj ) ;
(3) (desde C++26)
template < class M >
iterator insert_or_assign ( const_iterator hint, const Key & k, M && obj ) ;
(4) (desde C++17)
template < class M >
iterator insert_or_assign ( const_iterator hint, Key && k, M && obj ) ;
(5) (desde C++17)
template < class K, class M >
iterator insert_or_assign ( const_iterator hint, K && k, M && obj ) ;
(6) (desde C++26)
1,4) Si ya existe una clave equivalente a k en el contenedor, asigna std:: forward < M > ( obj ) al mapped_type correspondiente a la clave k . Si la clave no existe, inserta el nuevo valor como si fuera mediante insert , construyéndolo a partir de value_type ( k, std:: forward < M > ( obj ) ) .
2,5) Igual que (1,4) , excepto que el valor mapeado se construye a partir de value_type ( std :: move ( k ) , std:: forward < M > ( obj ) ) .
3,6) Si ya existe una clave equivalente a k en el contenedor, asigna std:: forward < M > ( obj ) al mapped_type correspondiente a la clave k . Si la clave no existe, construye un objeto u de value_type con std:: forward < K > ( k ) , std:: forward < M > ( obj ) ) , luego inserta u en * this . Si hash_function ( ) ( u. first ) ! = hash_function ( ) ( k ) || contains ( u. first ) es true , el comportamiento es indefinido. El value_type debe ser EmplaceConstructible en unordered_map desde std:: forward < K > ( k ) , std:: forward < M > ( obj ) . Esta sobrecarga participa en la resolución de sobrecarga solo si Hash y KeyEqual son ambos transparentes . Esto asume que dicho Hash puede ser invocado tanto con el tipo K como con el tipo Key , y que el KeyEqual es transparente, lo que, en conjunto, permite llamar a esta función sin construir una instancia de Key .

El comportamiento es indefinido (hasta C++20) El programa está mal formado (desde C++20) si std:: is_assignable_v < mapped_type & , M && > es false .

Si después de la operación el nuevo número de elementos es mayor que el antiguo max_load_factor() * bucket_count() se produce una redistribución.
Si ocurre redistribución (debido a la inserción), todos los iteradores quedan invalidados. En caso contrario (sin redistribución), los iteradores no se invalidan.

Contenidos

Parámetros

k - la clave utilizada tanto para buscar como para insertar si no se encuentra
hint - iterador a la posición antes de la cual se insertará el nuevo elemento
obj - el valor a insertar o asignar

Valor de retorno

1-3) El componente bool es true si la inserción tuvo lugar y false si la asignación tuvo lugar. El componente iterador apunta al elemento que fue insertado o actualizado.
4-6) Iterador que apunta al elemento que fue insertado o actualizado.

Complejidad

1-3) Igual que para emplace .
4-6) Igual que para emplace_hint .

Notas

insert_or_assign proporciona más información que operator [ ] y no requiere que el tipo mapeado sea default-constructible.

Macro de prueba de características Valor Std Característica
__cpp_lib_unordered_map_try_emplace 201411L (C++17) std::unordered_map::try_emplace ,
std::unordered_map::insert_or_assign
__cpp_lib_associative_heterogeneous_insertion 202311L (C++26) Sobrecargas heterogéneas para las funciones miembro restantes en contenedores asociativos ordenados y desordenados . Sobrecargas ( 3 ) y ( 6 ) .

Ejemplo

Ejecutar este código 
#include <iostream>
#include <string>
#include <unordered_map>
void print_node(const auto& node)
{
    std::cout << '[' << node.first << "] = " << node.second << '\n';
}
void print_result(auto const& pair)
{
    std::cout << (pair.second ? "inserted: " : "assigned: ");
    print_node(*pair.first);
}
int main()
{
    std::unordered_map<std::string, std::string> myMap;
    print_result(myMap.insert_or_assign("a", "apple"));
    print_result(myMap.insert_or_assign("b", "banana"));
    print_result(myMap.insert_or_assign("c", "cherry"));
    print_result(myMap.insert_or_assign("c", "clementine"));
    for (const auto& node : myMap)
        print_node(node);
}

Salida posible: 

inserted: [a] = apple
inserted: [b] = banana
inserted: [c] = cherry
assigned: [c] = clementine
[c] = clementine
[a] = apple
[b] = banana

Véase también

acceder o insertar elemento especificado
(función miembro pública)
acceder elemento especificado con verificación de límites
(función miembro pública)
inserta elementos o nodos (desde C++17)
(función miembro pública)
construye elemento in situ
(función miembro pública)