std::unordered_set merge() method

since C++17

// (1) Non const version only
template<class H2, class P2>
void merge( std::unordered_set<Key, T, H2, P2, Allocator>& source );

// (2) Non const version only
template<class H2, class P2>
void merge( std::unordered_set<Key, T, H2, P2, Allocator>&& source );

// (3) Non const version only
template<class H2, class P2>
void merge( std::unordered_multimap<Key, T, H2, P2, Allocator>& source );

// (4) Non const version only
template<class H2, class P2>
void merge( std::unordered_multimap<Key, T, H2, P2, Allocator>&& source );

Attempts to extract ("splice") each element in source and insert it into *this using the hash function and key equality predicate of *this.

If there is an element in *this with key equivalent to the key of an element from source, then that element is not extracted from source. No elements are copied or moved, only the internal pointers of the container nodes are repointed.

important

All pointers and references to the transferred elements remain valid, but now refer into *this, not into source.

Invalidation

Iterators referring to the transferred elements and *all iterators referring to this are invalidated.

Iterators to elements remaining in source remain valid.

Undefined behaviour

The behavior is undefined if get_allocator() != source.get_allocator().

Parameters

• source - compatible container to transfer the nodes from

Return value

(none)

Complexity

Average case, linear in the size of source - O(source.size()).
Worst case - O(N * size() + N), where N is source.size().

Exceptions

(none)

Example

Main.cpp

Run this code
#include <iostream>
#include <unordered_set>
 
// print out a container
template <class Os, class K>
Os& operator<<(Os& os, const std::unordered_set<K>& v) {
    os << '[' << v.size() << "] {";
    bool o{};
    for (const auto& e : v)
        os << (o ? ", " : (o = 1, " ")) << e;
    return os << " }\n";
}
 
int main()
{
    std::unordered_set<char>
        p{ 'C', 'B', 'B', 'A' }, 
        q{ 'E', 'D', 'E', 'C' };
 
    std::cout << "p: " << p << "q: " << q;
 
    p.merge(q);
 
    std::cout << "p.merge(q);\n" << "p: " << p << "q: " << q;
}

Possible output

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