# std::forward_list<T,Allocator>::splice_after

> C++ Atlas: `cppatlas.com/w/cpp/container/forward_list/splice_after` | Source: https://en.cppreference.com/w/cpp/container/forward_list/splice_after | Domain: Containers | Standards: C++11

Moves elements from another forward_list to *this. The elements are inserted after the element pointed to by pos.

## Official Specification Summary (cppreference)

```cpp
void splice_after( const_iterator pos, forward_list& other ); // (1) (since C++11)

void splice_after( const_iterator pos, forward_list&& other ); // (2) (since C++11)

void splice_after( const_iterator pos, forward_list& other,
                   const_iterator it ); // (3) (since C++11)

void splice_after( const_iterator pos, forward_list&& other,
                   const_iterator it ); // (4) (since C++11)

void splice_after( const_iterator pos, forward_list& other,
                   const_iterator first, const_iterator last ); // (5) (since C++11)

void splice_after( const_iterator pos, forward_list&& other,
                   const_iterator first, const_iterator last ); // (6) (since C++11)
```

Moves elements from another `forward_list` to `*this`. The elements are inserted after the element pointed to by `pos`.

No elements are copied. No iterators or references become invalidated. The iterators to the moved elements now refer into `*this`, not into `other`.

1,2) Moves all elements from `other` into `*this`. The container `other` becomes empty after the operation.

3,4) Moves the element pointed to by the iterator following `it` from `other` into `*this`. Has no effect if `pos == it` or if `pos == ++it`.

5,6) Moves the elements in the range `(first,` `last)` from `other` into `*this`. The element pointed-to by `first` is not moved.

The behavior is undefined if

- `get_allocator() != other.get_allocator()`,
- `pos` is neither `before_begin()` nor a dereferenceable iterator in `[begin(),` `end())`,
- for overloads (1,2), `*this` and `other` refer to the same object,
- for overloads (3,4), the iterator following `it` is not a dereferenceable iterator into `other`, or
- for overloads (5,6),

  - `(first,` `last)` is not a valid range in `other`,
  - some iterators in `(first,` `last)` are not dereferenceable, or
  - `pos` is in `(first,` `last)`.

### Parameters

- `pos` - element after which the content will be inserted
- `other` - another container to move the content from
- `it` - iterator preceding the iterator to the element to move from `other` to `*this`
- `first, last` - the range of elements to move from `other` to `*this`

### Exceptions

Throws nothing.

### Complexity

1,2) Linear in the size of `other`.

3,4) Constant.

5,6) Linear in `std::distance(first, last)`.

### Example

```cpp
#include <cassert>
#include <forward_list>

int main()
{
    using F = std::forward_list<int>;

    // Demonstrate the meaning of open range (first, last)
    // in overload (5): the first element of l1 is not moved.
    F l1 = {1, 2, 3, 4, 5};
    F l2 = {10, 11, 12};

    l2.splice_after(l2.cbegin(), l1, l1.cbegin(), l1.cend());
    // Not equivalent to l2.splice_after(l2.cbegin(), l1);
    // which is equivalent to
    // l2.splice_after(l2.cbegin(), l1, l1.cbefore_begin(), l1.end());

    assert((l1 == F{1}));
    assert((l2 == F{10, 2, 3, 4, 5, 11, 12}));

    // Overload (1)
    F x = {1, 2, 3, 4, 5};
    F y = {10, 11, 12};
    x.splice_after(x.cbegin(), y);
    assert((x == F{1, 10, 11, 12, 2, 3, 4, 5}));
    assert((y == F{}));

    // Overload (3)
    x = {1, 2, 3, 4, 5};
    y = {10, 11, 12};
    x.splice_after(x.cbegin(), y, y.cbegin());
    assert((x == F{1, 11, 2, 3, 4, 5}));
    assert((y == F{10, 12}));

    // Overload (5)
    x = {1, 2, 3, 4, 5};
    y = {10, 11, 12};
    x.splice_after(x.cbegin(), y, y.cbegin(), y.cend());
    assert((x == F{1, 11, 12, 2, 3, 4, 5}));
    assert((y == F{10}));
}
```

### Defect reports

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

| DR | Applied to | Behavior as published | Correct behavior |
| --- | --- | --- | --- |
| LWG 2045 | C++11 | O(1) splicing could not be guaranteed if `get_allocator() != other.get_allocator()` | the behavior is undefined in this case |
| LWG 2222 | C++11 | the element pointed to by `it` is not moved, but pointers, references and iterators referring to it would refer to an element in `*this` after splicing | still refer to the element in `other` |

### See also

- [`merge`](https://en.cppreference.com/w/cpp/container/forward_list/merge): merges two sorted lists (public member function)
- [`remove`](https://en.cppreference.com/w/cpp/container/forward_list/remove), [`remove_if`](https://en.cppreference.com/w/cpp/container/forward_list/remove): removes elements satisfying specific criteria (public member function)
- [`before_begin`](https://en.cppreference.com/w/cpp/container/forward_list/before_begin), [`cbefore_begin`](https://en.cppreference.com/w/cpp/container/forward_list/before_begin): returns an iterator to the element before beginning (public member function)

---
Attribution: content from https://en.cppreference.com/w/cpp/container/forward_list/splice_after (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.