std::inplace_vector

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

std::inplace_vector ist ein dynamisch in der Größe verä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 Compilezeit festgelegt und entspricht N.

Die Elemente werden zusammenhängend gespeichert, was bedeutet, dass auf Elemente nicht nur über Iteratoren oder wahlfreien Zugriff operator[] zugegriffen werden kann, sondern auch über Offsets auf reguläre Zeiger 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.

std::inplace_vector erfüllt die Anforderungen von Container, ReversibleContainer, ContiguousContainer und SequenceContainer, einschließlich der meisten optionalen sequentiellen Containeranforderungen, mit der Ausnahme, dass die Memberfunktionen push_front, emplace_front, pop_front und prepend_range nicht bereitgestellt werden.

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

Die Spezialisierung std::inplace_vector<T, 0> ist TriviallyCopyable und 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 üblicher Operationen auf inplace_vectors ist wie folgt:

• Wahlfreier Zugriff 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 dem Abstand 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

Mitgliedstypen

Memberfunktionen

Nicht-Member-Funktionen

Anmerkungen

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

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

Beispiel

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

Siehe auch

Externe Links