std::inplace_vector

template<
    class T,
    std::size_t N
> struct inplace_vector;

std::inplace_vector es un arreglo redimensionable dinámicamente con almacenamiento contiguo inplace. Los elementos de tipo T se almacenan y alinean adecuadamente dentro del propio objeto. La capacidad del almacenamiento interno se fija en tiempo de compilación y es igual a N.

Los elementos se almacenan de forma contigua, lo que significa que se puede acceder a ellos no solo a través de iteradores o operator[] de acceso aleatorio, sino también usando desplazamientos a punteros regulares a los elementos. Un puntero a un elemento de un inplace_vector se puede pasar a cualquier función que espere un puntero a un elemento de un arreglo C.

std::inplace_vector cumple con los requisitos de Container, ReversibleContainer, ContiguousContainer y SequenceContainer, incluyendo la mayoría de los requisitos opcionales de contenedor secuencial, excepto que las push_front, emplace_front, pop_front y prepend_range funciones miembro no están proporcionadas.

Para cualquier N, std::inplace_vector<T, N>::iterator y std::inplace_vector<T, N>::const_iterator cumplen con los requisitos de ConstexprIterator.

La especialización std::inplace_vector<T, 0> es TriviallyCopyable y está vacía. std::is_trivially_default_constructible_v<std::inplace_vector<T, 0>> también es true.

Cualquier función miembro de std::inplace_vector<T, N> que causaría una inserción más allá de la capacidad N lanza std::bad_alloc.

La complejidad de las operaciones comunes en inplace_vectors es la siguiente:

• Acceso aleatorio a un elemento mediante operator[] o at() – constante: 𝓞(1).
• Inserción o eliminación de un elemento al final – constante: 𝓞(1).
• Inserción o eliminación de elementos al final – lineal en el número de elementos insertados/eliminados: 𝓞(n).
• Inserción o eliminación de elementos al principio o en el medio – lineal en el número de elementos insertados/eliminados más la distancia al final del vector: 𝓞(n).

Invalidación de iteradores

std::inplace_vector las garantías de invalidación de iteradores difieren de std::vector :

• mover un inplace_vector invalida todos los iteradores;
• intercambiar dos inplace_vector s invalida todos los iteradores (durante el intercambio, el iterador continuará apuntando al mismo elemento del array, y por lo tanto podría cambiar su valor).

Las siguientes funciones miembro potencialmente invalidan iteradores: operator= , assign , assign_range , clear , emplace , erase , insert , insert_range , pop_back , resize , y swap .

Las siguientes funciones miembro potencialmente invalidan end únicamente el iterador: append_range , emplace_back , push_back , try_append_range , try_emplace_back , try_push_back , unchecked_emplace_back , y unchecked_push_back .

Parámetros de plantilla

Tipos de miembros

Funciones miembro

Funciones no miembro

Notas

El número de elementos en un inplace_vector puede variar dinámicamente hasta una capacidad fija porque los elementos se almacenan dentro del objeto mismo de manera similar a std::array. Sin embargo, los objetos se inicializan a medida que se insertan en inplace_vector a diferencia de los arrays de C o std::array, que deben construir todos los elementos al momento de la instanciación.

inplace_vector es útil en entornos donde las asignaciones de memoria dinámica no son deseadas.

Ejemplo

#include <algorithm>
#include <array>
#include <cassert>
#include <inplace_vector>
#include <optional>

int main()
{
    std::inplace_vector<int, 4> v1{0, 1, 2};
    assert(v1.max_size() == 4);
    assert(v1.capacity() == 4);
    assert(v1.size() == 3);
    assert(std::ranges::equal(v1, std::array{0, 1, 2}));
    assert(v1[0] == 0);
    assert(v1.at(0) == 0);
    assert(v1.front() == 0);
    assert(*v1.begin() == 0);
    assert(v1.back() == 2);
    v1.push_back(3);
    assert(v1.back() == 3);
    assert(std::ranges::equal(v1, std::array{0, 1, 2, 3}));
    v1.resize(3);
    assert(std::ranges::equal(v1, std::array{0, 1, 2}));
    assert(v1.try_push_back(3) != std::nullopt);
    assert(v1.back() == 3);
    assert(v1.size() == 4);
    assert(v1.try_push_back(13) == std::nullopt); // no place
    assert(v1.back() == 3);
    assert(v1.size() == 4);
    v1.clear();
    assert(v1.size() == 0);
    assert(v1.empty());
}

Véase también

Enlaces externos