std::set::merge(3)

NAME
std::set::merge - std::set::merge

Synopsis
   template<class C2> (1) (since C++17)
   void merge( std::set<Key, C2, Allocator>& source );
   template<class C2> (2) (since C++17)
   void merge( std::set<Key, C2, Allocator>&& source );
   template<class C2> (3) (since C++17)
   void merge( std::multiset<Key, C2, Allocator>& source );
   template<class C2> (4) (since C++17)
   void merge( std::multiset<Key, C2, Allocator>&& source );
   Attempts to extract ("splice") each element in source and insert it into *this using
   the comparison object 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. All pointers and references to the transferred elements remain
   valid, but now refer into *this, not into source.
   The behavior is undefined if get_allocator() != source.get_allocator().

Parameters
   source - compatible container to transfer the nodes from

Return value
   (none)

Exceptions
   Does not throw unless comparison throws.

Complexity
   N*log(size()+N)), where N is source.size().

Example
// Run this code
 #include <iostream>
 #include <set>
 // print out a container
 template <class Os, class K>
 Os& operator<<(Os& os, const std::set<K>& v) {
     os << '[' << v.size() << "] {";
     bool o{};
     for (const auto& e : v)
         os << (o ? ", " : (o = 1, " ")) << e;
     return os << " }\n";
 }
 int main()
 {
     std::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;
 }

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

See also
   extract extracts nodes from the container
   (C++17) (public member function)
           inserts elements
   insert or nodes
           (since C++17)
           (public member function)