std::list::splice(3)

NAME
std::list::splice - std::list::splice

Synopsis
   void splice( const_iterator pos, list& other ); (1)
   void splice( const_iterator pos, list&& other ); (1) (since C++11)
   void splice( const_iterator pos, list& other, const_iterator it ); (2)
   void splice( const_iterator pos, list&& other, const_iterator it (2) (since C++11)
   );
   void splice( const_iterator pos, list& other, (3)
   const_iterator first, const_iterator last);
   void splice( const_iterator pos, list&& other, (3) (since C++11)
   const_iterator first, const_iterator last );
   Transfers elements from one list to another.
   No elements are copied or moved, only the internal pointers of the list nodes are
   re-pointed. The behavior is undefined if: get_allocator() != other.get_allocator().
   No iterators or references become invalidated, the iterators to moved elements
   remain valid, but now refer into *this, not into other.
   1) Transfers all elements from other into *this. The elements are inserted before
   the element pointed to by pos. The container other becomes empty after the
   operation. The behavior is undefined if other refers to the same object as *this.
   2) Transfers the element pointed to by it from other into *this. The element is
   inserted before the element pointed to by pos.
   3) Transfers the elements in the range [first, last) from other into *this. The
   elements are inserted before the element pointed to by pos. The behavior is
   undefined if pos is an iterator in the range [first,last).

Parameters
   pos - element before which the content will be inserted
   other - another container to transfer the content from
   it - the element to transfer from other to *this
   first, last - the range of elements to transfer from other to *this

Return value
   (none)

Exceptions
   Throws nothing.

Complexity
   1-2) Constant.
   3) Constant if other refers to the same object as *this, otherwise linear in
   std::distance(first, last).

Example
// Run this code
 #include <iostream>
 #include <list>
 std::ostream& operator<<(std::ostream& ostr, const std::list<int>& list)
 {
     for (auto &i : list) {
         ostr << " " << i;
     }
     return ostr;
 }
 int main ()
 {
     std::list<int> list1 = { 1, 2, 3, 4, 5 };
     std::list<int> list2 = { 10, 20, 30, 40, 50 };
     auto it = list1.begin();
     std::advance(it, 2);
     list1.splice(it, list2);
     std::cout << "list1: " << list1 << "\n";
     std::cout << "list2: " << list2 << "\n";
     list2.splice(list2.begin(), list1, it, list1.end());
     std::cout << "list1: " << list1 << "\n";
     std::cout << "list2: " << list2 << "\n";
 }

Output:
 list1: 1 2 10 20 30 40 50 3 4 5
 list2:
 list1: 1 2 10 20 30 40 50
 list2: 3 4 5

See also
   merge merges two sorted lists
             (public member function)
   remove removes elements satisfying specific criteria
   remove_if (public member function)