Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::map
Member functions
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
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 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 equal_range ( u. first ) == equal_range ( k ) est false , 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 l'identifiant qualifié Compare :: is_transparent est valide et désigne un type.
Si equal_range ( u. first ) == equal_range ( k ) est false , le comportement est indéfini, où u est le nouvel élément à insérer.

Aucun itérateur ou référence n'est invalidé.

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 :
Logarithmique par rapport à la taille du conteneur.
4-6) Identique à emplace_hint :
Logarithmique par rapport à la taille du conteneur en général, mais constant amorti si le nouvel élément est inséré juste avant hint .

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 des maps dont les valeurs sont de types non copiables, tels que std:: 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_map_try_emplace 201411L (C++17) std::map::try_emplace , std::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 non ordonnés . Surcharges ( 3 ) et ( 6 ) .

Exemple

Exécuter ce code 
#include <iostream>
#include <string>
#include <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::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 : 

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

Voir aussi

(C++11)
construit un élément en place
(fonction membre publique)
(C++11)
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)