Namespaces
Variants

std::inplace_vector<T,N>:: insert

From cppreference.net
C++
Containers library
std::inplace_vector
Member types
Member functions
Non-member functions
constexpr iterator insert ( const_iterator pos, const T & value ) ;
(1) (depuis C++26)
constexpr iterator insert ( const_iterator pos, T && value ) ;
(2) (depuis C++26)
constexpr iterator insert ( const_iterator pos, size_type count, const T & value ) ;
(3) (depuis C++26)
template < class InputIt >
constexpr iterator insert ( const_iterator pos, InputIt first, InputIt last ) ;
(4) (depuis C++26)
constexpr iterator insert ( const_iterator pos, std:: initializer_list < T > ilist ) ;
(5) (depuis C++26)

Insère des éléments à l'emplacement spécifié dans le conteneur.

1) Insère une copie de value avant pos .
2) Insère value avant pos , en utilisant potentiellement la sémantique de déplacement.
3) Insère count copies de la value avant pos .
4) Insère les éléments de la plage [ first , last ) avant pos . Cette surcharge participe à la résolution de surcharge uniquement si InputIt est un LegacyInputIterator (pour éviter toute ambiguïté avec la surcharge (3) ).
Chaque itérateur dans [ first , last ) est déréférencé une fois.
Si first et last sont des itérateurs pointant vers * this , le comportement est indéfini.
5) Insère les éléments de la liste d'initialisation ilist avant pos . Équivalent à : insert ( pos, ilist. begin ( ) , ilist. end ( ) ) ; .
Cette section est incomplète

Table des matières

Paramètres

pos - itérateur avant lequel le contenu sera inséré ( pos peut être l'itérateur end() )
value - valeur de l'élément à insérer
count - nombre d'éléments à insérer
first, last - paire d'itérateurs définissant la plage source des éléments à insérer
ilist - std::initializer_list depuis laquelle insérer les valeurs
Exigences de type
-
T doit satisfaire aux exigences de CopyInsertable pour utiliser la surcharge (1).
-
T doit satisfaire aux exigences de MoveInsertable pour utiliser la surcharge (2).
-
T doit satisfaire aux exigences de CopyAssignable et CopyInsertable pour utiliser la surcharge (3).
-
T doit satisfaire aux exigences de EmplaceConstructible pour utiliser les surcharges (4,5).

Valeur de retour

1,2) Itérateur pointant vers la value insérée.
3) Itérateur pointant vers le premier élément inséré, ou pos si count == 0 .
4) Itérateur pointant vers le premier élément inséré, ou pos si first == last .
5) Itérateur pointant vers le premier élément inséré, ou pos si ilist est vide.

Complexité

Linéaire dans le nombre d'éléments insérés plus la distance entre pos et end() du conteneur.

Exceptions

Exemple

Exécuter ce code 
#include <initializer_list>
#include <inplace_vector>
#include <iterator>
#include <new>
#include <print>
int main()
{
    std::inplace_vector<int, 14> v(3, 100);
    std::println("1. {}", v);
    auto pos = v.begin();
    pos = v.insert(pos, 200); // surcharge (1)
    std::println("2. {}", v);
    v.insert(pos, 2, 300); // surcharge (3)
    std::println("3. {}", v);
    int arr[] = {501, 502, 503};
    v.insert(v.begin(), arr, arr + std::size(arr)); // surcharge (4)
    std::println("4. {}", v);
    v.insert(v.end(), {601, 602, 603}); // surcharge (5)
    std::println("5. {}", v);
    const auto list = {-13, -12, -11};
    try
    {
        v.insert(v.begin(), list); // lève une exception : pas d'espace
    }
    catch(const std::bad_alloc&)
    {
        std::println("bad_alloc: v.capacity()={} < v.size()={} + list.size()={}",
                     v.capacity(), v.size(), list.size());
    }
}

Sortie : 

1. [100, 100, 100]
2. [200, 100, 100, 100]
3. [300, 300, 200, 100, 100, 100]
4. [501, 502, 503, 300, 300, 200, 100, 100, 100]
5. [501, 502, 503, 300, 300, 200, 100, 100, 100, 601, 602, 603]
bad_alloc: v.capacity()=14 < v.size()=12 + list.size()=3

Voir aussi

construit un élément en place
(fonction membre publique)
insère une plage d'éléments
(fonction membre publique)