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) (depuis C++11)
(constexpr depuis C++26)
void splice_after ( const_iterator pos, forward_list && other ) ;
(2) (depuis C++11)
(constexpr depuis C++26)
void splice_after ( const_iterator pos, forward_list & other,
const_iterator it ) ;
(3) (depuis C++11)
(constexpr depuis C++26)
void splice_after ( const_iterator pos, forward_list && other,
const_iterator it ) ;
(4) (depuis C++11)
(constexpr depuis C++26)
void splice_after ( const_iterator pos, forward_list & other,
const_iterator first, const_iterator last ) ;
(5) (depuis C++11)
(constexpr depuis C++26)
void splice_after ( const_iterator pos, forward_list && other,
const_iterator first, const_iterator last ) ;
(6) (depuis C++11)
(constexpr depuis C++26)

Transfère les éléments de other vers * this . Les éléments sont insérés après pos .

Si l'une des conditions suivantes est satisfaite, le comportement est indéfini :

  • pos n'est pas dans l'intervalle ( before_begin() , end() ) .
  • get_allocator ( ) == other. get_allocator ( ) est false .
1,2) Transfère tous les éléments de other . other devient vide après l'opération.
Si * this et other font référence au même objet, le comportement est indéfini.
3,4) Transfère l'élément suivant it .
* this et other peuvent faire référence au même objet. Dans ce cas, il n'y a aucun effet si pos == it ou pos == ++ it est true .
Si ++ it n'est pas dans l'intervalle [ begin ( ) , end ( ) ) , le comportement est indéfini.
5,6) Transfère les éléments dans la plage ( first , last ) .
* this et other peuvent faire référence au même objet.
Si l'une des conditions suivantes est satisfaite, le comportement est indéfini :
  • ( first , last ) n'est pas une plage valide dans other ,
  • Un itérateur dans ( first , last ) n'est pas déréférençable.
  • pos se trouve dans ( first , last ) .

Aucun itérateur ou référence n'est invalidé. Si * this et other font référence à des objets différents, les itérateurs pointant vers les éléments transférés se réfèrent désormais à * this , et non à other .

Table des matières

Paramètres

pos - élément après lequel le contenu sera inséré
other - autre conteneur depuis lequel transférer le contenu
it - itérateur précédant l'itérateur vers l'élément à transférer de other vers * this
first, last - paire d'itérateurs définissant la plage d'éléments à transférer de other vers * this

Exceptions

1-4) Ne lance rien.

Complexité

1,2) Linéaire en fonction de la taille de other .
3,4) Constant.
5,6) Linéaire en std:: distance ( first, last ) .

Exemple

Exécuter ce code 
#include <cassert>
#include <forward_list>
int main()
{
    using F = std::forward_list<int>;
    // Démontre la signification de la plage ouverte (first, last)
    // dans la surcharge (5) : le premier élément de l1 n'est pas transféré.
    F l1 = {1, 2, 3, 4, 5};
    F l2 = {10, 11, 12};
    l2.splice_after(l2.cbegin(), l1, l1.cbegin(), l1.cend());
    // N'est pas équivalent à l2.splice_after(l2.cbegin(), l1);
    // ce qui est équivalent à
    // 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}));
    // Surcharge (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{}));
    // Surcharge (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}));
    // Surcharge (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}));
}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement correct
LWG 2045 C++11 La complexité O(1) ne pouvait être garantie si
get_allocator ( ) ! = other. get_allocator ( ) 		le comportement est
indéfini dans ce cas
LWG 2222 C++11 l'élément pointé par it n'est pas transféré, mais les pointeurs, références et
itérateurs s'y référant se référeraient à un élément dans * this après le transfert 		se réfèrent toujours à
l'élément dans other

Voir aussi

fusionne deux listes triées
(fonction membre publique)
supprime les éléments satisfaisant des critères spécifiques
(fonction membre publique)
retourne un itérateur vers l'élément précédant le début
(fonction membre publique)