std:: inplace_vector

inplace_vector ist ein dynamisch größenveränderbares Array mit zusammenhängendem Inplace-Speicher. Die Elemente vom Typ T werden innerhalb des Objekts selbst gespeichert und korrekt ausgerichtet. Die Kapazität des internen Speichers ist zur Kompilierzeit festgelegt und entspricht N .

Die Elemente werden zusammenhängend gespeichert, was bedeutet, dass auf Elemente nicht nur über Iteratoren oder den wahlfreien Zugriff operator [ ] zugegriffen werden kann, sondern auch über Offsets zu regulären Zeigern auf Elemente. Ein Zeiger auf ein Element eines inplace_vector kann an jede Funktion übergeben werden, die einen Zeiger auf ein Element eines C-Arrays erwartet.

Das inplace_vector modelliert Container , ReversibleContainer , ContiguousContainer und SequenceContainer , einschließlich der meisten optionalen Sequence-Container-Anforderungen , mit Ausnahme der Member-Funktionen push_front , emplace_front , pop_front und prepend_range , die nicht bereitgestellt werden.

Für jede positive N erfüllen std::inplace_vector<T, N>::iterator und std::inplace_vector<T, N>::const_iterator die ConstexprIterator -Anforderungen.

Die Spezialisierung std :: inplace_vector < T, 0 > ist TriviallyCopyable und ist leer. std:: is_trivially_default_constructible_v < std :: inplace_vector < T, 0 >> ist ebenfalls true .

Jede Memberfunktion von std :: inplace_vector < T, N > , die eine Einfügung über die Kapazität N hinaus verursachen würde, wirft std::bad_alloc .

Die Komplexität gängiger Operationen auf inplace_vector s ist wie folgt:

• Direktzugriff auf ein Element über operator[] oder at() – konstant: 𝓞(1) .
• Einfügen oder Entfernen eines Elements am Ende – konstant: 𝓞(1) .
• Einfügen oder Entfernen von Elementen am Ende – linear in der Anzahl der eingefügten/entfernten Elemente: 𝓞(n) .
• Einfügen oder Entfernen von Elementen am Anfang oder in der Mitte – linear in der Anzahl der eingefügten/entfernten Elemente plus der Entfernung zum Ende des Vektors: 𝓞(n) .

Iterator-Invalidierung

std::inplace_vector Iterator-Invalidierungsgarantien unterscheiden sich von std::vector :

• Das Verschieben eines inplace_vector macht alle Iteratoren ungültig;
• Das Austauschen zweier inplace_vector s macht alle Iteratoren ungültig (während des Austauschs zeigt der Iterator weiterhin auf dasselbe Array-Element und kann somit seinen Wert ändern).

Die folgenden Memberfunktionen können möglicherweise Iteratoren ungültig machen: operator= , assign , assign_range , clear , emplace , erase , insert , insert_range , pop_back , resize , und swap .

Die folgenden Memberfunktionen machen potenziell nur den end -Iterator ungültig: append_range , emplace_back , push_back , try_append_range , try_emplace_back , try_push_back , unchecked_emplace_back , und unchecked_push_back .

Template-Parameter

Mitgliedertypen

Memberfunktionen

Nicht-Member-Funktionen

Hinweise

Die Anzahl der Elemente in einem inplace_vector kann dynamisch bis zu einer festen Kapazität variieren, da Elemente ähnlich wie bei std::array innerhalb des Objekts selbst gespeichert werden. Allerdings werden Objekte initialisiert, wenn sie in den inplace_vector eingefügt werden, anders als bei C-Arrays oder std::array , die alle Elemente bei der Instanziierung konstruieren müssen.

inplace_vector ist nützlich in Umgebungen, in denen dynamische Speicherallokationen unerwünscht sind.

Beispiel

#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); // kein Platz
    assert(v1.back() == 3);
    assert(v1.size() == 4);
    v1.clear();
    assert(v1.size() == 0);
    assert(v1.empty());
}

Siehe auch

Externe Links