Namespaces
Variants

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

From cppreference.net
C++
Containers library
std::forward_list
Member functions
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
Deduction guides (C++17)
void splice_after ( const_iterator pos, forward_list & other ) ;
(1) (desde C++11)
(constexpr desde C++26)
void splice_after ( const_iterator pos, forward_list && other ) ;
(2) (desde C++11)
(constexpr desde C++26)
void splice_after ( const_iterator pos, forward_list & other,
const_iterator it ) ;
(3) (desde C++11)
(constexpr desde C++26)
void splice_after ( const_iterator pos, forward_list && other,
const_iterator it ) ;
(4) (desde C++11)
(constexpr desde C++26)
void splice_after ( const_iterator pos, forward_list & other,
const_iterator first, const_iterator last ) ;
(5) (desde C++11)
(constexpr desde C++26)
void splice_after ( const_iterator pos, forward_list && other,
const_iterator first, const_iterator last ) ;
(6) (desde C++11)
(constexpr desde C++26)

Transfiere elementos desde other hacia * this . Los elementos se insertan después de pos .

Si se satisface cualquiera de las siguientes condiciones, el comportamiento es indefinido:

1,2) Transfiere todos los elementos de other . other queda vacío después de la operación.
Si * this y other se refieren al mismo objeto, el comportamiento es indefinido.
3,4) Transfiere el elemento que sigue a it .
* this y other pueden referirse al mismo objeto. En este caso, no hay efecto si pos == it o pos == ++ it es true .
Si ++ it no está en el rango [ begin ( ) , end ( ) ) , el comportamiento es indefinido.
5,6) Transfiere elementos en el rango ( first , last ) .
* this y other pueden referirse al mismo objeto.
Si se satisface cualquiera de las siguientes condiciones, el comportamiento es indefinido:
  • ( first , last ) no es un rango válido en other ,
  • Cualquier iterador en ( first , last ) no es desreferenciable.
  • pos está en ( first , last ) .

No se invalidan iteradores ni referencias. Si * this y other hacen referencia a objetos diferentes, los iteradores de los elementos transferidos ahora hacen referencia a * this , no a other .

Contenidos

Parámetros

pos - elemento después del cual se insertará el contenido
other - otro contenedor del cual transferir el contenido
it - iterador que precede al iterador del elemento a transferir desde other a * this
first, last - el par de iteradores que define el rango de elementos a transferir desde other a * this

Excepciones

1-4) No lanza nada.

Complejidad

1,2) Lineal en el tamaño de other .
3,4) Constante.
5,6) Lineal en std:: distance ( first, last ) .

Ejemplo

Ejecutar este código 
#include <cassert>
#include <forward_list>
int main()
{
    using F = std::forward_list<int>;
    // Demostrar el significado del rango abierto (first, last)
    // en la sobrecarga (5): el primer elemento de l1 no se transfiere.
    F l1 = {1, 2, 3, 4, 5};
    F l2 = {10, 11, 12};
    l2.splice_after(l2.cbegin(), l1, l1.cbegin(), l1.cend());
    // No es equivalente a l2.splice_after(l2.cbegin(), l1);
    // que es equivalente a
    // 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}));
    // Sobrecarga (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{}));
    // Sobrecarga (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}));
    // Sobrecarga (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}));
}

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 2045 C++11 No se podía garantizar el splicing O(1) si
get_allocator ( ) ! = other. get_allocator ( ) 		el comportamiento es
indefinido en este caso
LWG 2222 C++11 el elemento apuntado por it no se transfiere, pero punteros, referencias e
iteradores que se refieren a él se referirían a un elemento en * this después del splicing 		aún se refieren al
elemento en other

Véase también

combina dos listas ordenadas
(función miembro pública)
elimina elementos que cumplen criterios específicos
(función miembro pública)
devuelve un iterador al elemento anterior al inicio
(función miembro pública)