std::list<T,Allocator>:: splice

Transfers elements from one list to another.

No elements are copied or moved, only the internal pointers of the list nodes are re-pointed. No iterators or references become invalidated, the iterators to moved elements remain valid, but now refer into * this , not into other .

The behavior is undefined if

• get_allocator ( ) ! = other. get_allocator ( ) ,
• for overloads (1,2) , * this and other refer to the same object,
• for overloads (3,4) , it is not a dereferenceable iterator into other , or
• for overloads (5,6) ,

• [ first , last ) is not a valid range in other , or
• pos is in [ first , last ) .

Parameters

Return value

(none)

Exceptions

Throws nothing.

Complexity

Example

#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';
}

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

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

See also