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

Tente d'extraire («splicer») chaque élément dans source et de l'insérer dans * this en utilisant la fonction de hachage et le prédicat d'égalité des clés de * this . S'il existe un élément dans * this avec une clé équivalente à la clé d'un élément de source , alors cet élément n'est pas extrait de source . Si get_allocator ( ) == source. get_allocator ( ) est false , le comportement est indéfini.

Aucun élément n'est copié ni déplacé, seuls les pointeurs internes des nœuds du conteneur sont redirigés. Tous les pointeurs et références vers les éléments transférés restent valides, mais se réfèrent désormais à * this , et non à source . Les itérateurs référençant les éléments transférés et tous les itérateurs référençant * this sont invalidés. Les itérateurs vers les éléments restant dans source restent valides.

Paramètres

Complexité

Soit \(\scriptsize S\) S comme size ( ) et \(\scriptsize N\) N comme source. size ( ) :

Exemple

#include <iostream>
#include <string>
#include <unordered_map>
#include <utility>
// afficher un std::pair
template<class Os, class U, class V>
Os& operator<<(Os& os, const std::pair<U,V>& p)
{
    return os << '{' << p.first << ", " << p.second << '}';
}
// afficher un conteneur associatif
template<class Os, class K, class V>
Os& operator<<(Os& os, const std::unordered_map<K, V>& v)
{
    os << '[' << v.size() << "] {";
    bool o{};
    for (const auto& e : v)
        os << (o ? ", " : (o = 1, "")) << e;
    return os << "}\n";
}
int main()
{
    std::unordered_map<std::string, int>
        p{{"C", 3}, {"B", 2}, {"A", 1}, {"A", 0}},
        q{{"E", 6}, {"E", 7}, {"D", 5}, {"A", 4}};
    std::cout << "p: " << p << "q: " << q;
    p.merge(q);
    std::cout << "p.merge(q);\n" << "p: " << p << "q: " << q;
}

p: [3] {{A, 1}, {B, 2}, {C, 3}}
q: [3] {{A, 4}, {D, 5}, {E, 6}}
p.merge(q);
p: [5] {{E, 6}, {D, 5}, {A, 1}, {B, 2}, {C, 3}}
q: [1] {{A, 4}}

Voir aussi