std::inplace_vector

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

std::inplace_vector est un tableau redimensionnable dynamiquement avec un stockage contigu sur place. Les éléments de type T sont stockés et correctement alignés dans l'objet lui-même. La capacité du stockage interne est fixée à la compilation et est égale à N.

Les éléments sont stockés de manière contiguë, ce qui signifie qu'ils peuvent être accédés non seulement via des itérateurs ou un accès aléatoire operator[], mais aussi en utilisant des décalages sur des pointeurs ordinaires vers les éléments. Un pointeur vers un élément d'un inplace_vector peut être passé à toute fonction qui attend un pointeur vers un élément d'un tableau C.

std::inplace_vector satisfait aux exigences de Container, ReversibleContainer, ContiguousContainer et SequenceContainer, y compris la plupart des exigences optionnelles pour les conteneurs séquentiels, sauf que les fonctions membres push_front, emplace_front, pop_front et prepend_range ne sont pas fournies.

Pour tout N, std::inplace_vector<T, N>::iterator et std::inplace_vector<T, N>::const_iterator satisfont aux exigences de ConstexprIterator.

La spécialisation std::inplace_vector<T, 0> est TriviallyCopyable et est vide. std::is_trivially_default_constructible_v<std::inplace_vector<T, 0>> est également true.

Toute fonction membre de std::inplace_vector<T, N> qui provoquerait une insertion au-delà de la capacité N lève std::bad_alloc.

La complexité des opérations courantes sur les inplace_vector est la suivante :

• Accès aléatoire à un élément via operator[] ou at() – constant : 𝓞(1).
• Insertion ou suppression d'un élément à la fin – constant : 𝓞(1).
• Insertion ou suppression d'éléments à la fin – linéaire en fonction du nombre d'éléments insérés/supprimés : 𝓞(n).
• Insertion ou suppression d'éléments au début ou au milieu – linéaire en fonction du nombre d'éléments insérés/supprimés plus la distance jusqu'à la fin du vecteur : 𝓞(n).

Invalidation des itérateurs

std::inplace_vector Les garanties d'invalidation des itérateurs diffèrent de celles de std::vector :

• déplacer un inplace_vector invalide tous les itérateurs ;
• échanger deux inplace_vector s invalide tous les itérateurs (pendant l'échange, l'itérateur continuera de pointer vers le même élément du tableau, et peut donc changer de valeur).

Les fonctions membres suivantes peuvent potentiellement invalider les itérateurs : operator= , assign , assign_range , clear , emplace , erase , insert , insert_range , pop_back , resize , et swap .

Les fonctions membres suivantes invalident potentiellement uniquement l'itérateur end : append_range , emplace_back , push_back , try_append_range , try_emplace_back , try_push_back , unchecked_emplace_back , et unchecked_push_back .

Paramètres du modèle

Types membres

Fonctions membres

Fonctions non membres

Notes

Le nombre d'éléments dans un inplace_vector peut varier dynamiquement jusqu'à une capacité fixe car les éléments sont stockés dans l'objet lui-même, similaire à std::array. Cependant, les objets sont initialisés lorsqu'ils sont insérés dans inplace_vector contrairement aux tableaux C ou std::array, qui doivent construire tous les éléments lors de l'instanciation.

inplace_vector est utile dans les environnements où les allocations mémoire dynamiques ne sont pas souhaitées.

Exemple

#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());
}

Voir aussi

Liens externes