Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::unordered_map
Member types
Member functions
Non-member functions
Deduction guides (C++17)
template < class ... Args >
std:: pair < iterator, bool > try_emplace ( const Key & k, Args && ... args ) ;
(1) (depuis C++17)
template < class ... Args >
std:: pair < iterator, bool > try_emplace ( Key && k, Args && ... args ) ;
(2) (depuis C++17)
template < class K, class ... Args >
std:: pair < iterator, bool > try_emplace ( K && k, Args && ... args ) ;
(3) (depuis C++26)
template < class ... Args >
iterator try_emplace ( const_iterator hint, const Key & k, Args && ... args ) ;
(4) (depuis C++17)
template < class ... Args >
iterator try_emplace ( const_iterator hint, Key && k, Args && ... args ) ;
(5) (depuis C++17)
template < class K, class ... Args >
iterator try_emplace ( const_iterator hint, K && k, Args && ... args ) ;
(6) (depuis C++26)

Si une clé équivalente à k existe déjà dans le conteneur, ne fait rien. Sinon, insère un nouvel élément dans le conteneur avec la clé k et la valeur construite avec args . Dans ce cas :

1) Se comporte comme emplace sauf que l'élément est construit comme
value_type ( std:: piecewise_construct ,

std:: forward_as_tuple ( k ) ,

std:: forward_as_tuple ( std:: forward < Args > ( args ) ... ) )
2) Se comporte comme emplace sauf que l'élément est construit comme
value_type ( std:: piecewise_construct ,

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

std:: forward_as_tuple ( std:: forward < Args > ( args ) ... ) )
3) Se comporte comme emplace sauf que l'élément est construit comme
value_type ( std:: piecewise_construct ,

std:: forward_as_tuple ( std:: forward < K > ( k ) ) ,

std:: forward_as_tuple ( std:: forward < Args > ( args ) ... ) )
4) Se comporte comme emplace_hint sauf que l'élément est construit comme
value_type ( std:: piecewise_construct ,

std:: forward_as_tuple ( k ) ,

std:: forward_as_tuple ( std:: forward < Args > ( args ) ... ) )
5) Se comporte comme emplace_hint sauf que l'élément est construit comme
value_type ( std:: piecewise_construct ,

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

std:: forward_as_tuple ( std:: forward < Args > ( args ) ... ) )
6) Se comporte comme emplace_hint sauf que l'élément est construit comme
value_type ( std:: piecewise_construct ,

std:: forward_as_tuple ( std:: forward < K > ( k ) ) ,

std:: forward_as_tuple ( std:: forward < Args > ( args ) ... ) )
1-6) Si value_type n'est pas EmplaceConstructible dans unordered_map à partir de l'expression correspondante, le comportement est indéfini.
3) Cette surcharge participe à la résolution de surcharge uniquement si toutes les conditions suivantes sont satisfaites :
Si hash_function ( ) ( u. first ) ! = hash_function ( ) ( k ) || contains ( u. first ) est true , le comportement est indéfini, où u est le nouvel élément à insérer.
6) Cette surcharge participe à la résolution de surcharge uniquement si Hash :: is_transparent et KeyEqual :: is_transparent sont tous deux valides et chacun désigne un type.
Si hash_function ( ) ( u. first ) ! = hash_function ( ) ( k ) || contains ( u. first ) est true , le comportement est indéfini, où u est le nouvel élément à insérer.

Si après l'opération le nouveau nombre d'éléments est supérieur à l'ancien max_load_factor() * bucket_count() un rehashing a lieu.
Si un rehashing se produit (en raison de l'insertion), tous les itérateurs sont invalidés. Sinon (aucun rehashing), les itérateurs ne sont pas invalidés.

Table des matières

Paramètres

k - la clé utilisée à la fois pour la recherche et pour l'insertion si non trouvée
hint - itérateur vers la position avant laquelle le nouvel élément sera inséré
args - arguments à transmettre au constructeur de l'élément

Valeur de retour

1-3) Identique à emplace :
Une paire constituée d'un itérateur vers l'élément inséré (ou vers l'élément qui a empêché l'insertion) et une valeur bool définie à true si et seulement si l'insertion a eu lieu.
4-6) Identique à emplace_hint :
Un itérateur vers l'élément inséré, ou vers l'élément qui a empêché l'insertion.

Complexité

1-3) Identique à emplace :
Amorti constant en moyenne, pire cas linéaire en fonction de la taille du conteneur.
4-6) Identique à emplace_hint :
Amorti constant en moyenne, pire cas linéaire en fonction de la taille du conteneur.

Notes

Contrairement à insert ou emplace , ces fonctions ne déplacent pas les arguments rvalue si l'insertion n'a pas lieu, ce qui facilite la manipulation de maps dont les valeurs sont de types uniquement déplaçables, tels que std:: unordered_map < std:: string , std:: unique_ptr < foo >> . De plus, try_emplace traite la clé et les arguments du mapped_type séparément, contrairement à emplace , qui nécessite les arguments pour construire un value_type (c'est-à-dire un std::pair ).

Surcharges ( 3 ) et ( 6 ) peuvent être appelées sans construire un objet de type Key .

Macro de test de fonctionnalité Valeur Norme Fonctionnalité
__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) Surcharges hétérogènes pour les fonctions membres restantes dans les conteneurs associatifs ordonnés et associatifs non ordonnés . Surcharges ( 3 ) et ( 6 ) .

Exemple

Exécuter ce code 
#include <iostream>
#include <string>
#include <unordered_map>
#include <utility>
void print_node(const auto& node)
{
    std::cout << '[' << node.first << "] = " << node.second << '\n';
}
void print_result(auto const& pair)
{
    std::cout << (pair.second ? "inserted: " : "ignored:  ");
    print_node(*pair.first);
}
int main()
{
    using namespace std::literals;
    std::unordered_map<std::string, std::string> m;
    print_result(m.try_emplace("a", "a"s));
    print_result(m.try_emplace("b", "abcd"));
    print_result(m.try_emplace("c", 10, 'c'));
    print_result(m.try_emplace("c", "Won't be inserted"));
    for (const auto& p : m)
        print_node(p);
}

Sortie possible : 

inserted: [a] = a
inserted: [b] = abcd
inserted: [c] = cccccccccc
ignored:  [c] = cccccccccc
[a] = a
[b] = abcd
[c] = cccccccccc

Voir aussi

construit un élément en place
(fonction membre publique)
construit des éléments en place en utilisant un indice
(fonction membre publique)
insère des éléments ou des nœuds (depuis C++17)
(fonction membre publique)