Namespaces
Variants

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

From cppreference.net
C++
Containers library
std::inplace_vector
Member types
Member functions
Non-member functions
constexpr inplace_vector ( ) noexcept ;
(1) (desde C++26)
constexpr explicit inplace_vector ( size_type count ) ;
(2) (desde C++26)
constexpr inplace_vector ( size_type count, const T & value ) ;
(3) (desde C++26)
template < class InputIt >
constexpr inplace_vector ( InputIt first, InputIt last ) ;
(4) (desde C++26)
template < container-compatible-range < T > R >
constexpr inplace_vector ( std:: from_range_t , R && rg ) ;
(5) (desde C++26)
constexpr inplace_vector ( const inplace_vector & other ) ;
(6) (desde C++26)
constexpr inplace_vector ( inplace_vector && other )
noexcept ( N == 0 || std:: is_nothrow_move_constructible_v < T > ) ;
(7) (desde C++26)
constexpr inplace_vector ( std:: initializer_list < T > init ) ;
(8) (desde C++26)

Construye un nuevo inplace_vector a partir de diversas fuentes de datos.

1) Construye un inplace_vector vacío cuyo data ( ) == nullptr y size ( ) == 0 .
2) Construye un inplace_vector con count elementos insertados por defecto.
3) Construye un inplace_vector con count copias de elementos con valor value .
4) Construye un inplace_vector con los contenidos del rango [ first , last ) .
5) Construye un inplace_vector con el contenido del rango rg .
6) Un copy constructor . Construye un inplace_vector con la copia de los contenidos de other .
El constructor es un trivial copy constructor si N > 0 y std:: is_trivially_copy_constructible_v < T > son ambos true .
7) Un move constructor . Construye un inplace_vector con el contenido de other utilizando semántica de movimiento.
El constructor es un trivial move constructor si N > 0 y std:: is_trivially_move_constructible_v < T > son ambos true .
8) Construye un inplace_vector con el contenido de la lista de inicialización init .

Contenidos

Parámetros

count - el tamaño del contenedor
value - el valor para inicializar los elementos del contenedor
first, last - el par de iteradores que define el rango fuente de elementos a copiar
rg - el rango de valores para inicializar los elementos del contenedor
other - otro inplace_vector que se usará como fuente para inicializar los elementos del contenedor
init - lista de inicialización para inicializar los elementos del contenedor
Requisitos de tipo
-
T debe cumplir con los requisitos de DefaultInsertable para usar las sobrecargas (2,3).

Complejidad

1) Constante.
2,3) Lineal en count .
4) Lineal en std:: distance ( first, last ) .
5) Lineal en std :: ranges:: distance ( rg ) .
6,7) Lineal en el tamaño de other .
8) Lineal en tamaño de init .

Excepciones

2,3) Lanza std::bad_alloc si count > N .
5) Lanza std::bad_alloc si std :: ranges:: size ( rg ) > N .
8) Lanza std::bad_alloc si init. size ( ) > N .

Ejemplo

Ejecutar este código 
#include <cassert>
#include <initializer_list>
#include <inplace_vector>
#include <new>
#include <print>
#include <ranges>
int main()
{
    std::inplace_vector<int, 4> v1; // sobrecarga (1)
    assert(v1.size() == 0 && v1.capacity() == 4);
    std::inplace_vector<int, 0> v2; // sobrecarga (1), se permite N == 0
    assert(v2.size() == 0 && v2.capacity() == 0);
    std::inplace_vector<int, 5> v3(3); // sobrecarga (2)
    assert(v3.size() == 3 && v3.capacity() == 5);
    std::println("v3 = {}", v3);
    try
    {
        std::inplace_vector<int, 3> v(4); // sobrecarga (2), lanza: count > N
    }
    catch(const std::bad_alloc& ex1)
    {
        std::println("ex1.what(): {}", ex1.qué());
    }
    std::inplace_vector<int, 5> v4(3, 8); // sobrecarga (3)
    assert(v4.size() == 3 && v4.capacity() == 5);
    std::println("v4 = {}", v4);
    try
    {
        std::inplace_vector<int, 3> v(4, 2); // sobrecarga (3), lanza: count > N
    }
    catch(const std::bad_alloc& ex2)
    {
        std::println("ex2.what(): {}", ex2.qué());
    }
    const auto init = {1, 2, 3};
    std::inplace_vector<int, 4> v5(init.begin(), init.end()); // sobrecarga (4)
    assert(v5.size() == 3 && v5.capacity() == 4);
    std::println("v5 = {}", v5);
    std::inplace_vector<int, 4> v6(std::from_range, init); // sobrecarga (5)
    assert(v6.size() == 3 && v6.capacity() == 4);
    std::println("v6 = {}", v6);
    std::inplace_vector<int, 4> v7(v6); // sobrecarga (6)
    assert(v7.size() == 3 && v7.capacity() == 4);
    std::println("v7 = {}", v7);
    assert(v6.size() == 3);
    std::inplace_vector<int, 4> v8(std::move(v6)); // sobrecarga (7)
    // Nota que después del movimiento v6 queda en un estado válido pero indeterminado.
    assert(v8.size() == 3 && v8.capacity() == 4);
    std::println("v8 = {}", v8);
    std::inplace_vector<int, 4> v9(init); // sobrecarga (8)
    assert(v9.size() == 3 && v9.capacity() == 4);
    std::println("v9 = {}", v9);
    try
    {
        std::inplace_vector<int, 2> v(init); // sobrecarga (8), lanza: init.size() > N
    }
    catch(const std::bad_alloc& ex3)
    {
        std::println("ex3.what(): {}", ex3.qué());
    }
}

Salida posible: 

v3 = [0, 0, 0]
ex1.what(): std::bad_alloc
v4 = [42, 42, 42]
ex2.what(): std::bad_alloc
v5 = [1, 2, 3]
v6 = [1, 2, 3]
v7 = [1, 2, 3]
v8 = [1, 2, 3]
v9 = [1, 2, 3]
ex3.what(): std::bad_alloc

Véase también

asigna valores al contenedor
(función miembro pública)
[static]
devuelve el número de elementos que pueden almacenarse en el almacenamiento actualmente asignado
(función miembro estática pública)
acceso directo al almacenamiento contiguo subyacente
(función miembro pública)
devuelve el número de elementos
(función miembro pública)
(C++17) (C++20)
devuelve el tamaño de un contenedor o array
(plantilla de función)
(C++17)
obtiene el puntero al array subyacente
(plantilla de función)