std::map<Key,T,Compare,Allocator>::try_emplace

 

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

Funciones miembro

map::map map::~map               map::operator= map::get_allocator

Acceso a elementos map::at map::operator[] Iteradores map::beginmap::cbegin (C++11) map::endmap::cend (C++11) map::rbeginmap::crbegin (C++11)      map::rendmap::crend (C++11) Capacidad map::size map::max_size map::empty Observadores map::key_comp map::value_comp Modificadores map::clear map::insert map::erase map::swap map::extract (C++17) map::merge (C++17) map::insert_range (C++23) map::insert_or_assign (C++17) map::emplace (C++11) map::emplace_hint (C++11) map::try_emplace (C++17) Búsqueda map::count map::find map::contains (C++20) map::equal_range map::lower_bound map::upper_bound

Funciones no miembro

operator==operator<=> (C++20) std::swap(std::map) erase_if(std::map) (C++20)   operator!=operator<operator>operator<=operator>= (hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)

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

 

template<class... Args> pair<iterator, bool> try_emplace(const Key& k, Args&&... args);	(1)	(desde C++17)
template<class... Args> pair<iterator, bool> try_emplace( Key&& k, Args&&... args);	(2)	(desde C++17)
template<class... Args> iterator try_emplace( const_iterator hint, const Key& k, Args&&... args);	(3)	(desde C++17)
template<class... Args> iterator try_emplace( const_iterator hint, Key&& k, Args&&... args);	(4)	(desde C++17)

Inserta un nuevo elemento en el contenedor con la clave k y el valor construido con args, si no hay ningún elemento con tal clave en el contenedor.

1) Si una clave equivalente a k ya existe en el contenedor, no hace nada. De lo contrario, se comporta como emplace excepto que el elemento se construye como
value_type(std::piecewise_construct,

           std::forward_as_tuple(k),

           std::forward_as_tuple(std::forward<Args>(args)...))

2) Si una clave equivalente a k ya existe en el contenedor, no hace nada. De lo contrario, se comporta como emplace excepto que el elemento se construye como
value_type(std::piecewise_construct,

           std::forward_as_tuple(std::move(k)),

           std::forward_as_tuple(std::forward<Args>(args)...))

3) Si una clave equivalente a k ya existe en el contenedor, no hace nada. De lo contrario, se comporta como emplace_hint excepto que el elemento se construye como
value_type(std::piecewise_construct,

           std::forward_as_tuple(k),

           std::forward_as_tuple(std::forward<Args>(args)...))

4) Si una clave equivalente a k ya existe en el contenedor, no hace nada. De lo contrario, se comporta como emplace_hint excepto que el elemento se construye como
value_type(std::piecewise_construct,

           std::forward_as_tuple(std::move(k)),

           std::forward_as_tuple(std::forward<Args>(args)...))

No se invalidan ni referencias ni iteradores.

Parámetros

k	-	La clave usada tanto para buscar como para insertar si no se encuentra.
hint	-	Un iterador a la posición antes de la cual se insertará el nuevo elemento.
args	-	Los argumentos a reenviar al constructor del elemento.

Valor de retorno

1,2) Igual que para emplace

3,4) Igual que para emplace_hint

Complejidad

1,2) Igual que para emplace

3,4) Igual que para emplace_hint

Notas

A diferencia de insert o emplace, estas funciones no se mueven de los argumentos r-valor si la inserción no ocurre, lo que facilita la manipulación de mapas cuyos valores son tipos de solo movimiento, tales como std::map<std::string, std::unique_ptr<foo>>. Además, try_emplace trata la clave y los argumentos al tipo mapped_type de manera separada, a diferencia de emplace, que requiere que los argumentos construyan un value_type (es decir, un std::pair).

Ejemplo

Ejecuta este código

#include <iostream>#include <utility>#include <string>   #include <map>   auto imprimir_nodo =[](constauto&nodo){std::cout<<"["<< nodo.first<<"] = "<< nodo.second<<'\n';};   auto imprimir_resultado =[](autoconst&pair){std::cout<<(pair.second?"insertado: ":"ignorado: "); imprimir_nodo(*pair.first);};   int main(){usingnamespace std::literals;std::map<std::string, std::string> m;   imprimir_resultado( m.try_emplace("a", "a"s)); imprimir_resultado( m.try_emplace("b", "abcd")); imprimir_resultado( m.try_emplace("c", 10, 'c')); imprimir_resultado( m.try_emplace("c", "No será insertado"));   for(constauto&p : m){ imprimir_nodo(p);}}

Salida:

insertado: [a] = a insertado: [b] = abcd insertado: [c] = cccccccccc ignorado: [c] = cccccccccc [a] = a [b] = abcd [c] = cccccccccc

Véase también

emplace (C++11)	Construye el elemento en el sitio. (función miembro pública)
emplace_hint (C++11)	Construye elementos en el sitio utilizando una pista. (función miembro pública)
insert	Inserta elementos o nodos(desde C++17) (función miembro pública)