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) (desde C++26)
constexpr iterator insert ( const_iterator pos, T && value ) ;
(2) (desde C++26)
constexpr iterator insert ( const_iterator pos, size_type count, const T & value ) ;
(3) (desde C++26)
template < class InputIt >
constexpr iterator insert ( const_iterator pos, InputIt first, InputIt last ) ;
(4) (desde C++26)
constexpr iterator insert ( const_iterator pos, std:: initializer_list < T > ilist ) ;
(5) (desde C++26)

Inserta elementos en la ubicación especificada del contenedor.

1) Inserta una copia de value antes de pos .
2) Inserta value antes de pos , posiblemente utilizando semántica de movimiento.
3) Inserta count copias del value antes de pos .
4) Inserta elementos del rango [ first , last ) antes de pos . Esta sobrecarga participa en la resolución de sobrecarga solo si InputIt es un LegacyInputIterator (para evitar ambigüedad con la sobrecarga (3) ).
Cada iterador en [ first , last ) es desreferenciado una vez.
Si first y last son iteradores de * this , el comportamiento es indefinido.
5) Inserta elementos desde la lista de inicialización ilist antes de pos . Equivalente a: insert ( pos, ilist. begin ( ) , ilist. end ( ) ) ; .
Esta sección está incompleta

Contenidos

Parámetros

pos - iterador antes del cual se insertará el contenido ( pos puede ser el end() iterator)
value - valor del elemento a insertar
count - número de elementos a insertar
first, last - el par de iteradores que define el rango fuente de elementos a insertar
ilist - std::initializer_list desde el cual insertar los valores
Requisitos de tipo
-
T debe cumplir con los requisitos de CopyInsertable para usar la sobrecarga (1).
-
T debe cumplir con los requisitos de MoveInsertable para usar la sobrecarga (2).
-
T debe cumplir con los requisitos de CopyAssignable y CopyInsertable para usar la sobrecarga (3).
-
T debe cumplir con los requisitos de EmplaceConstructible para usar las sobrecargas (4,5).

Valor de retorno

1,2) Iterador que apunta al valor insertado value .
3) Iterador que apunta al primer elemento insertado, o pos si count == 0 .
4) Iterador que apunta al primer elemento insertado, o pos si first == last .
5) Iterador que apunta al primer elemento insertado, o pos si ilist está vacío.

Complejidad

Lineal en el número de elementos insertados más la distancia entre pos y end() del contenedor.

Excepciones

Ejemplo

Ejecutar este código 
#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); // overload (1)
    std::println("2. {}", v);
    v.insert(pos, 2, 300); // overload (3)
    std::println("3. {}", v);
    int arr[] = {501, 502, 503};
    v.insert(v.begin(), arr, arr + std::size(arr)); // overload (4)
    std::println("4. {}", v);
    v.insert(v.end(), {601, 602, 603}); // overload (5)
    std::println("5. {}", v);
    const auto list = {-13, -12, -11};
    try
    {
        v.insert(v.begin(), list); // throws: no space
    }
    catch(const std::bad_alloc&)
    {
        std::println("bad_alloc: v.capacity()={} < v.size()={} + list.size()={}",
                     v.capacity(), v.size(), list.size());
    }
}

Salida: 

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

Véase también

construye el elemento in situ
(función miembro pública)
inserta un rango de elementos
(función miembro pública)