std::inplace_vector

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::inplace_vector

Membertypen
Memberfunktionen
inplace_vector::inplace_vector inplace_vector::~inplace_vector    inplace_vector::operator= inplace_vector::assign inplace_vector::assign_range Größe und Kapazität inplace_vector::empty inplace_vector::size inplace_vector::max_size inplace_vector::capacity inplace_vector::resize inplace_vector::reserve inplace_vector::shrink_to_fit Iteratoren inplace_vector::begininplace_vector::cbegin inplace_vector::endinplace_vector::cend inplace_vector::rbegininplace_vector::crbegin inplace_vector::rendinplace_vector::crend	Elementzugriff inplace_vector::at inplace_vector::operator[] inplace_vector::front inplace_vector::back inplace_vector::data Modifizierer inplace_vector::clear inplace_vector::erase inplace_vector::swap inplace_vector::insert inplace_vector::insert_range inplace_vector::emplace inplace_vector::emplace_back inplace_vector::try_emplace_back inplace_vector::unchecked_emplace_back inplace_vector::push_back inplace_vector::try_push_back inplace_vector::unchecked_push_back inplace_vector::pop_back inplace_vector::append_range inplace_vector::try_append_range
Nicht-Member-Funktionen
erase(std::inplace_vector)erase_if(std::inplace_vector) swap(std::inplace_vector)	operator==operator<=>

 

Definiert in Header <inplace_vector>
template<     class T,     std::size_t N > struct inplace_vector;		(seit C++26)

inplace_vector ist ein dynamisch größenveränderbarer Vektor mit speziellem Speicherplatz im Objekt. Die Elemente vom Typ T werden innerhalb des Objekts selbst gespeichert und richtig ausgerichtet. Die Kapazität des internen Speichers ist zur Kompilierungszeit festgelegt und entspricht N.

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

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

Für jedes positive N erfüllen std::inplace_vector<T, N>::iterator und std::inplace_vector<T, N>::const_iterator die Anforderungen an 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 Member-Funktion 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_vectors ist wie folgt:

• Zufallszugriff 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 zur Anzahl der eingefügten/entfernten Elemente: 𝓞(n).
• Einfügen oder Entfernen von Elementen am Anfang oder in der Mitte – linear zur Anzahl der eingefügten/entfernten Elemente zuzüglich der Entfernung zum Ende des Vektors: 𝓞(n).

Iterator-Invalidierung

Die Iterator-Invalidierungsgarantien von std::inplace_vector unterscheiden sich von denen von std::vector.

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

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

Die folgenden Member-Funktionen können nur den end-Iterator ungültig machen: append_range, emplace_back, push_back, try_append_range, try_emplace_back, try_push_back, unchecked_emplace_back und unchecked_push_back.

Template-Parameter

T	-	Elementtyp. Muss MoveConstructible und MoveAssignable sein.
N	-	Kapazität, d.h. die maximale Anzahl von Elementen im inplace_vector (kann ​0​ sein).

Member-Typen

Typ	Definition
value_type	T
size_type	std::size_t
difference_type	std::ptrdiff_t
Referenz	value_type&
const_reference	const value_type&
Zeiger	value_type*
const_pointer	const value_type*
iterator	Implementierungsdefinierter LegacyRandomAccessIterator und random_access_iterator zu value_type
const_iterator	Implementierungsdefinierter LegacyRandomAccessIterator, ConstexprIterator(seit C++26) und random_access_iterator zu const value_type
reverse_iterator	std::reverse_iterator<iterator>
const_reverse_iterator	std::reverse_iterator<const_iterator>

Member-Funktionen

(Konstruktor)	konstruiert den inplace_vector (public member function)
(Destruktor)	destruiert den inplace_vector (public member function)
operator=	weist dem Container Werte zu (public member function)
assign	weist dem Container Werte zu (public member function)
assign_range	weist dem Container einen Bereich von Werten zu (public member function)
Elementzugriff
at	Greift mit Überprüfung auf ein bestimmtes Element zu (public member function)
operator[]	Greift auf ein bestimmtes Element zu (public member function)
front	Greift auf das erste Element zu (public member function)
back	Greift auf das letzte Element zu (public member function)
data	Direkter Zugriff auf den zugrundeliegenden zusammenhängenden Speicher (public member function)
Iteratoren
begincbegin	gibt einen Iterator zum Anfang zurück (public member function)
endcend	gibt einen Iterator zum Ende zurück (public member function)
rbegincrbegin	gibt einen Reverse-Iterator zum Anfang zurück (public member function)
rendcrend	gibt einen Reverse-Iterator zum Ende zurück (public member function)
Größe und Kapazität
empty	prüft, ob der Container leer ist (public member function)
size	Gibt die Anzahl der Elemente zurück (public member function)
max_size [static]	Gibt die maximal mögliche Anzahl von Elementen zurück (public static member function)
capacity [static]	Gibt die Anzahl der Elemente zurück, die im derzeit zugewiesenen Speicher gehalten werden können (public static member function)
resize	ändert die Anzahl der gespeicherten Elemente (public member function)
reserve [static]	reserviert Speicher (public static member function)
shrink_to_fit [static]	reduziert den Speicherverbrauch durch Freigabe von ungenutztem Speicher (public static member function)
Modifizierer
insert	fügt Elemente ein (public member function)
insert_range	fügt einen Bereich von Elementen ein (public member function)
emplace	konstruiert Elemente direkt (in-place) (public member function)
emplace_back	konstruiert ein Element direkt (in-place) am Ende (public member function)
try_emplace_back	versucht, ein Element inplace am Ende zu konstruieren (public member function)
unchecked_emplace_back	konstruiert bedingungslos ein Element inplace am Ende (public member function)
push_back	fügt ein Element am Ende hinzu (public member function)
try_push_back	versucht, ein Element am Ende hinzuzufügen (public member function)
unchecked_push_back	fügt bedingungslos ein Element am Ende hinzu (public member function)
pop_back	entfernt das letzte Element (public member function)
append_range	fügt einen Bereich von Elementen am Ende hinzu (public member function)
try_append_range	versucht, einen Bereich von Elementen am Ende hinzuzufügen (public member function)
clear	leert den Inhalt (public member function)
erase	entfernt Elemente (public member function)
swap	tauscht die Inhalte (public member function)

Nicht-Member-Funktionen

std::swap(std::inplace_vector) (C++26)	spezialisiert den Algorithmus std::swap (function template)
erase(std::inplace_vector)erase_if(std::inplace_vector) (C++26)	entfernt alle Elemente, die bestimmte Kriterien erfüllen (function template)
operator==operator<=> (C++26)	vergleicht die Werte von zwei inplace_vectors lexikographisch (function template)

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. Objekte werden jedoch beim Einfügen in inplace_vector initialisiert, im Gegensatz zu C-Arrays oder std::array, die alle Elemente bei der Instanziierung konstruieren müssen.

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

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_inplace_vector	202406L	(C++26)	std::inplace_vector: dynamisch größenveränderbarer Vektor mit festem Kapazitäts-Inplace-Speicher
__cpp_lib_constexpr_inplace_vector	202502L	(C++26)	constexpr std::inplace_vector für nicht-triviale Elementtypen

Beispiel

Führen Sie diesen Code aus

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

Siehe auch

vector	reservierbares, zusammenhängendes Array (Klassenvorlage)
array (C++11)	fest dimensioniertes, inplace, zusammenhängendes Array (Klassenvorlage)
deque	Doppelt-endende Warteschlange (Klassenvorlage)

Externe Links

1.	inplace_vector — Eine Referenzimplementierung von P0843R14 (std::inplace_vector).
2.	static_vector — Boost.Container implementiert inplace vector als eigenständigen Typ mit eigenen Garantien.
3.	fixed_vector — EASTL implementiert inplace vector über einen zusätzlichen Template-Parameter.
4.	small_vector — Folly implementiert inplace vector ebenfalls über einen zusätzlichen Template-Parameter.
5.	stack_alloc — Howard Hinnants benutzerdefinierte Allokatoren, die std::inplace_vector auf Basis von std::vector emulieren.