Namespaces
Variants

std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>:: try_emplace

From cppreference.net
C++
Containers library
std::flat_map
Member types
Member functions
Non-member functions
Helper classes
Tags
Deduction guides
template < class ... Args >
std:: pair < iterator, bool > try_emplace ( const key_type & k, Args && ... args ) ;
(1) (depuis C++23)
template < class ... Args >
std:: pair < iterator, bool > try_emplace ( key_type && k, Args && ... args ) ;
(2) (depuis C++23)
template < class K, class ... Args >
std:: pair < iterator, bool > try_emplace ( K && k, Args && ... args ) ;
(3) (depuis C++23)
template < class ... Args >
iterator try_emplace ( const_iterator hint, const key_type & k, Args && ... args ) ;
(4) (depuis C++23)
template < class ... Args >
iterator try_emplace ( const_iterator hint, key_type && k, Args && ... args ) ;
(5) (depuis C++23)
template < class K, class ... Args >
iterator try_emplace ( const_iterator hint, K && k, Args && ... args ) ;
(6) (depuis C++23)

Si une clé équivalente à k existe déjà dans le conteneur, ne fait rien. Sinon, insère un nouvel élément dans les conteneurs sous-jacents c avec la clé k et la valeur construite avec args .

1,2,4,5) Équivalent à : 
auto key_it = ranges::upper_bound(c.keys, k, compare);
auto value_it = c.values.begin() + std::distance(c.keys.begin(), key_it);
c.keys.insert(key_it, std::forward<decltype(k)>(k));
c.values.emplace(value_it, std::forward<Args>(args)...);
3,6) Équivalent à : 
auto key_it = ranges::upper_bound(c.keys, k, compare);
auto value_it = c.values.begin() + std::distance(c.keys.begin(), key_it);
c.keys.emplace(key_it, std::forward<K>(k));
c.values.emplace(value_it, std::forward<Args>(args)...);
La conversion de k vers key_type doit construire un objet u pour lequel find ( k ) == find ( u ) est true . Sinon, le comportement est indéfini.
Ces surcharges participent à la résolution de surcharge uniquement si :
Les informations sur l'invalidation des itérateurs sont copiées depuis ici

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 .
4-6) Identique à emplace_hint .

Complexité

1-3) Identique à emplace .
4-6) Identique à emplace_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:: flat_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,6 ) peuvent être appelées sans construire un objet de type key_type .

Exemple

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

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
(fonction membre publique)
insère un élément ou assigne à l'élément actuel si la clé existe déjà
(fonction membre publique)