Namespaces
Variants

std::forward_list<T,Allocator>:: insert_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)
iterator insert_after ( const_iterator pos, const T & value ) ;
(1) (depuis C++11)
(constexpr depuis C++26)
iterator insert_after ( const_iterator pos, T && value ) ;
(2) (depuis C++11)
(constexpr depuis C++26)
iterator insert_after ( const_iterator pos,
size_type count, const T & value ) ;
(3) (depuis C++11)
(constexpr depuis C++26)
template < class InputIt >

iterator insert_after ( const_iterator pos,

InputIt first, InputIt last ) ;
(4) (depuis C++11)
(constexpr depuis C++26)
iterator insert_after ( const_iterator pos,
std:: initializer_list < T > ilist ) ;
(5) (depuis C++11)
(constexpr depuis C++26)

Insère des éléments après la position spécifiée dans le conteneur. Si pos est before_begin() , le premier élément inséré (s'il existe) deviendra le premier élément de * this .

Si pos n'est pas dans l'intervalle [ before_begin() , end() ) , le comportement est indéfini.

1,2) Insère une copie de value après pos .
1) Si T n'est pas CopyInsertable dans forward_list , le comportement est indéfini.
2) Si T n'est pas MoveInsertable dans forward_list , le comportement est indéfini.
3) Insère count copies de la value après pos .
Si T n'est pas CopyInsertable dans forward_list , le comportement est indéfini.
4) Insère les éléments de la plage [ first , last ) après pos .
Cette surcharge participe à la résolution de surcharge uniquement si InputIt satisfait aux exigences de LegacyInputIterator .
Si l'une des conditions suivantes est satisfaite, le comportement est indéfini :
  • T n'est pas EmplaceConstructible dans forward_list à partir de * first .
  • first ou last est un itérateur pointant vers * this .
5) Insère les éléments de la liste d'initialisation ilist après pos .
Équivalent à return insert_after ( position, ilist. begin ( ) , ilist. end ( ) ) ; .

Aucun itérateur ou référence n'est invalidé.

Table des matières

Paramètres

pos - itérateur après lequel le contenu sera inséré
value - valeur de l'élément à insérer
count - nombre de copies à insérer
first, last - paire d'itérateurs définissant la plage source des éléments à insérer
ilist - liste d'initialisation depuis laquelle insérer les valeurs

Valeur de retour

1,2) Itérateur vers l'élément inséré.
3) Itérateur vers le dernier élément inséré, ou pos si count == 0 est true .
4) Itérateur vers le dernier élément inséré, ou pos si first == last est true .
5) Itérateur vers le dernier élément inséré, ou pos si ilist est vide.

Exceptions

Si une exception est levée pour quelque raison que ce soit, ces fonctions n'ont aucun effet ( strong exception safety guarantee ).

Complexité

1,2) Constant.
3) Linéaire en count .
4) Linéaire en std:: distance ( first, last ) .
5) Linéaire en ilist. size ( ) .

Exemple

Exécuter ce code 
#include <forward_list>
#include <iostream>
#include <string>
#include <vector>
void print(const std::forward_list<int>& list)
{
    std::cout << "list: {";
    for (char comma[3] = {'\0', ' ', '\0'}; int i : list)
    {
        std::cout << comma << i;
        comma[0] = ',';
    }
    std::cout << "}\n";
}
int main()
{
    std::forward_list<int> ints{1, 2, 3, 4, 5};
    print(ints);
    // insert_after (2)
    auto beginIt = ints.begin();
    ints.insert_after(beginIt, -6);
    print(ints);
    // insert_after (3)
    auto anotherIt = beginIt;
    ++anotherIt;
    anotherIt = ints.insert_after(anotherIt, 2, -7);
    print(ints);
    // insert_after (4)
    const std::vector<int> v = {-8, -9, -10};
    anotherIt = ints.insert_after(anotherIt, v.cbegin(), v.cend());
    print(ints);
    // insert_after (5)
    ints.insert_after(anotherIt, {-11, -12, -13, -14});
    print(ints);
}

Sortie : 

list: {1, 2, 3, 4, 5}
list: {1, -6, 2, 3, 4, 5}
list: {1, -6, -7, -7, 2, 3, 4, 5}
list: {1, -6, -7, -7, -8, -9, -10, 2, 3, 4, 5}
list: {1, -6, -7, -7, -8, -9, -10, -11, -12, -13, -14, 2, 3, 4, 5}

Voir aussi

construit des éléments en place après un élément
(fonction membre publique)
insère un élément au début
(fonction membre publique)