std::forward_list::splice_after
De cppreference.com
void splice_after( const_iterator pos, forward_list& other );
|
(1) | (desde C++11) |
void splice_after( const_iterator pos, forward_list&& other );
|
(1) | (desde C++11) |
void splice_after( const_iterator pos, forward_list& other,
const_iterator it );
|
(2) | (desde C++11) |
void splice_after( const_iterator pos, forward_list&& other,
const_iterator it );
|
(2) | (desde C++11) |
void splice_after( const_iterator pos, forward_list& other,
const_iterator first, const_iterator last );
|
(3) | (desde C++11) |
void splice_after( const_iterator pos, forward_list&& other,
const_iterator first, const_iterator last );
|
(3) | (desde C++11) |
Mueve elementos de otro contenedor forward_list a *this.
No se copian elementos. pos debe ser ya sea un iterador válido desreferenciable en *this o el iterador before_begin() (en particular, end() no es un argumento válido para pos). El comportamiento no está definido si get_allocator() != other.get_allocator(). No se invalidan ni iteradores ni referencias, los iteradores a los elementos movidos ahora se refieren a *this, no a other.
1) Mueve todos los elementos de
other a *this. Los elementos se insertan después del elemento al que apunta pos. El contenedor other queda vacío después de la operación. El comportamiento no está definido si other se refiere al mismo objeto que *this.2) Mueve el elemento al que apunta el iterador que sigue a
it de other a *this. El elemento se inserta después del elemento al que apunta pos. No tiene efecto si pos==it o si pos==++it.3) Mueve los elementos en el rango
(first, last) de other a *this. Los elementos se insertan después del elemento al que apunta pos. El elemento al que apunta first no se mueve. El comportamiento no está definido si pos es un iterador en el rango (first,last).Parámetros
| pos | - | Iterador después del cual se insertará el contenido. |
| other | - | Otro contenedor del cual mover el contenido. |
| it | - | Iterador que precede al iterador del elemento a mover other a *this.
|
| first, last | - | El rango de elementos del cual mover other a *this.
|
Valor de retorno
(Ninguno)
Excepciones
No lanza nada.
Complejidad
1) Lineal en el tamaño de
other.2) Constante.
3) Lineal en
std::distance(first, last).Ejemplo
Demuestra el significado de un intervalo abierto (first, last) en la tercera forma de splice_after(): el primer elemento de l1 no se mueve.
Ejecuta este código
#include <algorithm>
#include <cassert>
#include <forward_list>
#include <initializer_list>
#include <iostream>
using F = std::forward_list<int>;
std::ostream& operator<< (std::ostream& os, F const& l) {
for (int e : l) os << e << ' ';
return os;
}
int main()
{
{
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());
std::cout << "l1: " << l1 << "\n"
"l2: " << l2 << '\n';
}
// Compara dos listas dadas y aborta el programa si no son iguales.
auto equ = [] (F const& p, std::initializer_list<int> const& q) {
assert(std::ranges::equal(p, q));
};
// El siguiente código demuestra las tres sobrecargas (1),..(3).
{
F x = { 1, 2, 3, 4, 5 };
F y = { 10, 11, 12 };
x.splice_after(x.cbegin(), y); // (1)
equ( x, { 1, 10, 11, 12, 2, 3, 4, 5 } );
equ( y, { } );
}
{
F x = { 1, 2, 3, 4, 5 };
F y = { 10, 11, 12 };
x.splice_after(x.cbegin(), y, y.cbegin()); // (2)
equ( x, { 1, 11, 2, 3, 4, 5 } );
equ( y, { 10, 12 } );
}
{
F x = { 1, 2, 3, 4, 5 };
F y = { 10, 11, 12 };
x.splice_after(x.cbegin(), y, y.cbegin(), y.cend()); // (3)
equ( x, { 1, 11, 12, 2, 3, 4, 5 } );
equ( y, { 10 } );
}
}
Salida:
l1: 1
l2: 10 2 3 4 5 11 12
Véase también
(C++11) |
Fusiona dos listas ordenadas. (función miembro pública) |
(C++11) |
Elimina elementos que satisfacen un criterio específico. (función miembro pública) |
(C++11) |
Devuelve un iterador al elemento antes del principio del contenedor. (función miembro pública) |