std:: inplace_vector

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 que les éléments peuvent être accédés non seulement via des itérateurs ou l'opérateur d'accès aléatoire operator [ ] , mais aussi en utilisant des décalages vers des pointeurs classiques 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.

Le inplace_vector modélise Container , ReversibleContainer , ContiguousContainer , et SequenceContainer , incluant la plupart des exigences optionnelles des conteneurs séquentiels , à l'exception que les fonctions membres push_front , emplace_front , pop_front , et prepend_range ne sont pas fournies.

Pour tout N positif, std::inplace_vector<T, N>::iterator et std::inplace_vector<T, N>::const_iterator satisfont aux exigences 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 entraînerait une insertion au-delà de la capacité N lance std::bad_alloc .

La complexité des opérations courantes sur les inplace_vector s 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 dans le nombre d'éléments insérés/supprimés : 𝓞(n) .
• Insertion ou suppression d'éléments au début ou au milieu – linéaire dans le 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, de manière similaire à std::array . Cependant, les objets sont initialisés lors de leur insertion dans le inplace_vector contrairement aux tableaux C ou au std::array , qui doivent construire tous les éléments lors de l'instanciation.

inplace_vector est utile dans les environnements où les allocations de mémoire dynamique sont indésirables.

Exemple

#include <algorithm>
#include <array>
#include <cassert>
#include <inplace_vector>
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) != nullptr);
    assert(v1.back() == 3);
    assert(v1.size() == 4);
    assert(v1.try_push_back(13) == nullptr); // pas de place
    assert(v1.back() == 3);
    assert(v1.size() == 4);
    v1.clear();
    assert(v1.size() == 0);
    assert(v1.empty());
}

Voir aussi

Liens externes