std::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::vector

Membertypen
Memberfunktionen
vector::vector vector::~vector vector::operator= vector::assign vector::assign_range (C++23)   vector::get_allocator Elementzugriff vector::operator[] vector::at vector::data vector::front vector::back Iteratoren vector::beginvector::cbegin (C++11) vector::endvector::cend (C++11) vector::rbeginvector::crbegin (C++11) vector::rendvector::crend (C++11)	Kapazität vector::empty vector::size vector::max_size vector::reserve vector::capacity vector::shrink_to_fit (DR*) Modifizierer vector::clear vector::erase vector::insert vector::insert_range (C++23) vector::append_range (C++23) vector::emplace (C++11) vector::emplace_back (C++11) vector::push_back vector::pop_back vector::resize vector::swap
Nicht-Member-Funktionen
operator==operator<=> (C++20) swap(std::vector) erase(std::vector)erase_if(std::vector) (C++20)(C++20)	operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Deduction guides(C++17)

 

Definiert in Header <vector>
template<     class T,     class Allocator = std::allocator<T> > class vector;	(1)
namespace pmr {     template< class T >     using vector = std::vector<T, std::pmr::polymorphic_allocator<T>>; }	(2)	(seit C++17)

1) std::vector ist ein Sequenzcontainer, der dynamisch große Arrays kapselt.

2) std::pmr::vector ist ein Alias-Template, das einen polymorphen Allokator verwendet.

Die Elemente werden zusammenhängend gespeichert, was bedeutet, dass die Elemente nicht nur über Iteratoren, sondern auch über Offsets zu regulären Zeigern auf Elemente zugänglich sind. Dies bedeutet, dass ein Zeiger auf ein Element eines Vektors an jede Funktion übergeben werden kann, die einen Zeiger auf ein Element eines Arrays erwartet.

Die Speicherung des Vektors wird automatisch gehandhabt und bei Bedarf erweitert. Vektoren beanspruchen normalerweise mehr Speicher als statische Arrays, da mehr Speicher für zukünftiges Wachstum zugewiesen wird. Auf diese Weise muss ein Vektor nicht bei jeder Einfügung eines Elements neu zugeteilt werden, sondern erst dann, wenn der zusätzliche Speicher erschöpft ist. Die Gesamtmenge des zugewiesenen Speichers kann mit der Funktion capacity() abgefragt werden. Zusätzlicher Speicher kann über einen Aufruf von shrink_to_fit() an das System zurückgegeben werden.

Neuallokationen sind in Bezug auf die Leistung normalerweise kostspielige Operationen. Die Funktion reserve() kann verwendet werden, um Neuallokationen zu vermeiden, wenn die Anzahl der Elemente im Voraus bekannt ist.

Die Komplexität (Effizienz) gängiger Operationen auf Vektoren ist wie folgt:

• Zufallszugriff – konstant 𝓞(1).
• Einfügen oder Entfernen von Elementen am Ende – amortisiert konstant 𝓞(1).
• Einfügen oder Entfernen von Elementen – linear in der Entfernung zum Ende des Vektors 𝓞(n).

std::vector (für T außer bool) erfüllt die Anforderungen von Container, AllocatorAwareContainer(seit C++11), SequenceContainer, ContiguousContainer(seit C++17) und ReversibleContainer.

Alle Memberfunktionen von std::vector sind constexpr: Es ist möglich, std::vector-Objekte in der Auswertung eines konstanten Ausdrucks zu erstellen und zu verwenden. std::vector-Objekte können jedoch im Allgemeinen nicht constexpr sein, da dynamisch zugewiesener Speicher in derselben Auswertung eines konstanten Ausdrucks freigegeben werden muss.

(seit C++20)

Template-Parameter

T	-	Der Typ der Elemente. T muss die Anforderungen von CopyAssignable und CopyConstructible erfüllen. (bis C++11) Die auf die Elemente angewendeten Anforderungen hängen von den tatsächlichen Operationen ab, die auf dem Container ausgeführt werden. Im Allgemeinen muss der Elementtyp ein vollständiger Typ sein und die Anforderungen von Erasable erfüllen, aber viele Memberfunktionen stellen strengere Anforderungen. (seit C++11) (bis C++17) Die auf die Elemente angewendeten Anforderungen hängen von den tatsächlichen Operationen ab, die auf dem Container ausgeführt werden. Im Allgemeinen muss der Elementtyp die Anforderungen von Erasable erfüllen, aber viele Memberfunktionen stellen strengere Anforderungen. Dieser Container (aber nicht seine Member) kann mit einem unvollständigen Elementtyp instanziiert werden, wenn der Allokator die Komplettheitsanforderungen des Allokators erfüllt. Feature-Test-Makro Wert Std Feature __cpp_lib_incomplete_container_elements 201505L (C++17) Minimale Unterstützung für unvollständige Typen (seit C++17)
Allocator	-	Ein Allokator, der zum Erwerb/Freigeben von Speicher und zum Erstellen/Zerstören der Elemente in diesem Speicher verwendet wird. Der Typ muss die Anforderungen von Allocator erfüllen. Das Verhalten ist undefiniert(bis C++20)Das Programm ist ill-formed(seit C++20), wenn Allocator::value_type nicht mit T übereinstimmt.

Spezialisierungen

Die Standardbibliothek stellt eine Spezialisierung von std::vector für den Typ bool zur Verfügung, die für die Speicherplatzersparnis optimiert sein kann.

vector<bool>

speichereffizientes dynamisches Bitset (class template specialization)

Iterator-Invalidierung

Operationen	Invalidiert
Alle Leseoperationen	Niemals.
swap, std::swap	end()
clear, operator=, assign	Immer.
reserve, shrink_to_fit	Wenn sich die Kapazität des Vektors geändert hat, alle. Andernfalls keine.
erase	Entfernte Elemente und alle nachfolgenden Elemente (einschließlich end()).
push_back, emplace_back	Wenn sich die Kapazität des Vektors geändert hat, alle. Andernfalls nur end().
insert, emplace	Wenn sich die Kapazität des Vektors geändert hat, alle. Andernfalls nur diejenigen ab dem Einfügepunkt (einschließlich end()).
resize	Wenn sich die Kapazität des Vektors geändert hat, alle. Andernfalls nur end() und alle entfernten Elemente.
pop_back	Das entfernte Element und end().

Member-Typen

Mitgliedertyp	Definition
value_type	T
allocator_type	Allocator
size_type	Vorzeichenloser Ganzzahltyp (normalerweise std::size_t)
difference_type	Vorzeichenbehafteter Ganzzahltyp (normalerweise std::ptrdiff_t)
Referenz	value_type&
const_reference	const value_type&
Zeiger	Allocator::pointer (bis C++11) std::allocator_traits<Allocator>::pointer (seit C++11)
const_pointer	Allocator::const_pointer (bis C++11) std::allocator_traits<Allocator>::const_pointer (seit C++11)
iterator	LegacyRandomAccessIterator und LegacyContiguousIterator zu value_type (bis C++20) LegacyRandomAccessIterator, contiguous_iterator, und ConstexprIterator zu value_type (seit C++20)
const_iterator	LegacyRandomAccessIterator und LegacyContiguousIterator zu const value_type (bis C++20) LegacyRandomAccessIterator, contiguous_iterator, und ConstexprIterator zu const value_type (seit C++20)
reverse_iterator	std::reverse_iterator<iterator>
const_reverse_iterator	std::reverse_iterator<const_iterator>

Memberfunktionen

(Konstruktor)	konstruiert den vector (public member function)
(Destruktor)	destruiert den vector (public member function)
operator=	weist dem Container Werte zu (public member function)
assign	weist dem Container Werte zu (public member function)
assign_range (C++23)	weist dem Container einen Bereich von Werten zu (public member function)
get_allocator	gibt den zugehörigen Allocator zurück (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 (C++11)	gibt einen Iterator zum Anfang zurück (public member function)
endcend (C++11)	gibt einen Iterator zum Ende zurück (public member function)
rbegincrbegin (C++11)	gibt einen Reverse-Iterator zum Anfang zurück (public member function)
rendcrend (C++11)	gibt einen Reverse-Iterator zum Ende zurück (public member function)
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	Gibt die maximal mögliche Anzahl von Elementen zurück (public member function)
reserve	reserviert Speicher (public member function)
capacity	Gibt die Anzahl der Elemente zurück, die im derzeit zugewiesenen Speicher gehalten werden können (public member function)
shrink_to_fit (DR*)	reduziert den Speicherverbrauch durch Freigabe von ungenutztem Speicher (public member function)
Modifizierer
clear	leert den Inhalt (public member function)
insert	fügt Elemente ein (public member function)
insert_range (C++23)	fügt einen Bereich von Elementen ein (public member function)
emplace (C++11)	konstruiert Elemente direkt (in-place) (public member function)
erase	entfernt Elemente (public member function)
push_back	fügt ein Element am Ende hinzu (public member function)
emplace_back (C++11)	konstruiert ein Element direkt (in-place) am Ende (public member function)
append_range (C++23)	fügt einen Bereich von Elementen am Ende hinzu (public member function)
pop_back	entfernt das letzte Element (public member function)
resize	ändert die Anzahl der gespeicherten Elemente (public member function)
swap	tauscht die Inhalte (public member function)

Nicht-Member-Funktionen

operator==operator!=operator<operator<=operator>operator>=operator<=> (entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)	vergleicht lexikographisch die Werte zweier vectors (function template)
std::swap(std::vector)	spezialisiert den Algorithmus std::swap (function template)
erase(std::vector)erase_if(std::vector) (C++20)	entfernt alle Elemente, die bestimmte Kriterien erfüllen (function template)

Deduction Guides

(seit C++17)

Hinweise

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_containers_ranges	202202L	(C++23)	Bereichskonstruktion und -einfügung für Container

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <vector>
 
int main()
{
    // Create a vector containing integers
    std::vector<int> v = {8, 4, 5, 9};
 
    // Add two more integers to vector
    v.push_back(6);
    v.push_back(9);
 
    // Overwrite element at position 2
    v[2] = -1;
 
    // Print out the vector
    for (int n : v)
        std::cout << n << ' ';
    std::cout << '\n';
}

Ausgabe

8 4 -1 9 6 9

Defect Reports

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 69	C++98	Die Zusammenhängung des Speichers für Elemente von vector wurde nicht gefordert	Gefordert
LWG 230	C++98	T musste nicht CopyConstructible sein (ein Element vom Typ T konnte möglicherweise nicht konstruiert werden)	T muss auch CopyConstructible sein
LWG 464	C++98	Der Zugriff auf den zugrundeliegenden Speicher eines leeren vector führte zu undefiniertem Verhalten	data-Funktion bereitgestellt

Siehe auch

inplace_vector (C++26)	reservierbares, festes Kapazitäts-Array, Inplace, zusammenhängend (Klassenvorlage)
array (C++11)	fest dimensioniertes, inplace, zusammenhängendes Array (Klassenvorlage)
deque	Doppelt-endende Warteschlange (Klassenvorlage)