`vector`-Klasse

Artikel
09/02/2023

Die C++-Standardbibliotheksvektorklasse ist eine Klassenvorlage für Sequenzcontainer. Ein Vektor speichert Elemente eines bestimmten Typs in einer linearen Anordnung und ermöglicht schnellen zufälligen Zugriff auf jedes Element. Ein Vektor ist der bevorzugte Container für eine Sequenz, wenn die Leistung des zufälligen Zugriffs premium ist.

Syntax

template <class Type, class Allocator = allocator<Type>>
class vector

Parameter

Type
Der im Vektor zu speichernde Elementdatentyp.

Allocator
Der Typ, der das gespeicherte allocator-Objekt darstellt, das Details zum Belegen und Freigeben von Arbeitsspeicher für den Vektor kapselt. Dieses Argument ist optional, und der Standardwert ist allocator<Type>.

Hinweise

Vektoren ermöglichen konstante Zeiteinfügungen und -löschungen am Ende der Sequenz. Für das Einfügen oder Löschen von Elementen in der Mitte eines Vektors ist lineare Zeit erforderlich. Der deque Klassencontainer ist bei Einfügungen und Löschungen am Anfang und Ende einer Sequenz schneller. Der list Klassencontainer ist bei Einfügungen und Löschungen an einer beliebigen Stelle innerhalb einer Sequenz schneller.

Eine Speicherneubelegung für einen Vektor findet statt, wenn eine Memberfunktion die Sequenz, die in dem vector-Objekt enthalten ist, über dessen aktuelle Speicherkapazität hinaus vergrößern muss. Andere Einfügungen und Löschungen können verschiedene Speicheradressen innerhalb der Sequenz ändern. In allen diesen Fällen werden Iteratoren oder Verweise auf geänderte Teile der Sequenz ungültig. Wenn keine Neuzuordnung stattfindet, bleiben nur Iteratoren und Verweise vor dem Einfüge-/Löschpunkt gültig.

Die vector<bool> Klasse ist eine vollständige Spezialisierung des Klassenvorlagenvektors für Elemente vom Typ bool. Es verfügt über einen Allokator für den zugrunde liegenden Typ, der von der Spezialisierung verwendet wird.

Die vector<bool> Referenzklasse ist eine geschachtelte Klasse, deren Objekte Verweise auf Elemente (einzelne Bits) innerhalb eines vector<bool> Objekts bereitstellen können.

Member

Konstruktoren

Name	Beschreibung
`vector`	Erstellt einen Vektor einer bestimmten Größe bzw. mit Elementen eines bestimmten Werts oder mit einem bestimmten `allocator`-Element oder als vollständige bzw. teilweise Kopie eines anderen Vektors.

TypeDefs

Name	Beschreibung
`[allocator_type]`(#allocator_type)	Ein Typ, der die `allocator`-Klasse für das Vektorobjekt darstellt.
`const_iterator`	Ein Typ, der einen Iterator mit wahlfreiem Zugriff bereitstellt, mit dem ein `const`-Element in einem Vektor gelesen werden kann.
`const_pointer`	Ein Typ, der einen Zeiger auf ein `const`-Element in einem Vektor bereitstellt.
`const_reference`	Ein Typ, der einen Verweis auf ein `const` element bereitstellt, das in einem Vektor gespeichert ist. Sie wird zum Lesen und Ausführen von `const` Vorgängen verwendet.
`const_reverse_iterator`	Ein Typ, der einen Iterator mit zufälligem Zugriff bereitstellt, mit dem jedes `const`-Element im Vektor gelesen werden kann.
`difference_type`	Ein Typ, der die Differenz zwischen den Adressen von zwei Elementen in einem Vektor bereitstellt.
`iterator`	Ein Typ, der einen Iterator mit wahlfreiem Zugriff bereitstellt, mit dem jedes Element in einem Vektor gelesen oder geändert werden kann.
`pointer`	Ein Typ, der einen Zeiger auf ein Element in einem Vektor bereitstellt.
`reference`	Ein Typ, der einen Verweis auf ein in einem Vektor gespeichertes Element bereitstellt.
`reverse_iterator`	Ein Typ, der einen Iterator mit zufälligem Zugriff bereitstellt, mit dem jedes Element in einem umgekehrten Vektor gelesen oder geändert werden kann.
`size_type`	Ein Typ, der die Anzahl von Elementen in einem Vektor zählt.
`value_type`	Ein Typ, der den in einem Vektor gespeicherten Datentyp darstellt.

Funktionen

Name	Beschreibung
`assign`	Löscht einen Vektor und kopiert die angegebenen Elemente in den leeren Vektor.
`at`	Gibt einen Verweis auf das Element an einer angegebenen Position in dem Vektor zurück.
`back`	Gibt einen Verweis auf das letzte Element des Vektors zurück.
`begin`	Gibt einen Iterator mit wahlfreiem Zugriff für das erste Element im Vektor zurück.
`capacity`	Gibt die Anzahl von Elementen zurück, die der Vektor enthalten kann, ohne zusätzlichen Speicher zuzuweisen.
`cbegin`	Gibt einen const-Iterator mit wahlfreiem Zugriff für das erste Element im Vektor zurück.
`cend`	Gibt einen für wahlfreien Zugriff eingerichteten konstanten Iterator zurück, der unmittelbar hinter das Ende des Vektors zeigt.
`crbegin`	Gibt einen const-Iterator zum ersten Element in einem umgekehrten Vektor zurück.
`crend`	Gibt einen const-Iterator zum Ende eines umgekehrten Vektors zurück.
`clear`	Löscht die Elemente des Vektors.
`data`	Gibt einen Zeiger auf das erste Element im Vektor zurück.
`emplace`	Fügt ein direkt konstruiertes Element an einer angegebenen Position in den Vektor ein.
`emplace_back`	Fügt ein direkt konstruiertes Element am Ende des Vektors ein.
`empty`	Testet, ob der Vektorcontainer leer ist.
`end`	Gibt einen Iterator mit wahlfreiem Zugriff zurück, der auf das Ende des Vektors zeigt.
`erase`	Entfernt ein Element oder eine Reihe von Elementen aus angegebenen Positionen in einem Vektor.
`front`	Gibt einen Verweis auf das erste Element in einem Vektor zurück.
`get_allocator`	Gibt ein Objekt an die `allocator`-Klasse zurück, das von einem Vektor verwendet wird.
`insert`	Fügt ein Element oder viele Elemente an einer angegebenen Position in den Vektor ein.
`max_size`	Gibt die Maximallänge des Vektors zurück.
`pop_back`	Löscht das Element am Ende des Vektors.
`push_back`	Fügt ein Element am Ende des Vektors hinzu.
`rbegin`	Gibt einen Iterator an das erste Element in einem umgekeherten Vektor zurück.
`rend`	Gibt einen Iterator zum Ende eines umgekehrten Vektors zurück.
`reserve`	Reserviert eine Mindestspeicherlänge für ein Vektorobjekt.
`resize`	Gibt eine neue Größe für einen Vektor an.
`shrink_to_fit`	Verwirft Überkapazität.
`size`	Gibt die Anzahl von Elementen in dem Vektor zurück.
`swap`	Tauscht die Elemente zweier Vektoren aus.

Operatoren

Name	Beschreibung
`operator[]`	Gibt einen Verweis auf das Vektorelement an einer angegebenen Position zurück.
`operator=`	Ersetzt die Elemente des Vektors durch eine Kopie eines anderen Vektors.

`allocator_type`

Ein Typ, der die Zuweisungsklasse für das Vektorobjekt darstellt.

typedef Allocator allocator_type;

Hinweise

allocator_type ist ein Synonym für den Vorlagenparameter Allocator.

Beispiel

Sehen Sie sich das Beispiel für ein Beispiel an get_allocator , das allocator_typeverwendet wird.

`assign`

Löscht einen Vektor und kopiert die angegebenen Elemente in den leeren Vektor.

void assign(size_type count, const Type& value);
void assign(initializer_list<Type> init_list);

template <class InputIterator>
void assign(InputIterator first, InputIterator last);

Parameter

first
Die Position des ersten Elements in dem zu kopierenden Elementbereich.

last
Die Position des ersten Elements nach dem zu kopierenden Elementbereich.

count
Die Anzahl von Kopien eines Elements, das in den Vektor eingefügt wird.

value
Der Wert des Elements, das in den Vektor eingefügt wird.

init_list
Das initializer_list-Element, in den die zu kopierenden Elemente eingefügt werden.

Hinweise

assign Löscht zunächst alle vorhandenen Elemente in einem Vektor. Fügen Sie dann assign entweder einen angegebenen Bereich von Elementen aus dem ursprünglichen Vektor in einen Vektor ein, oder sie fügt Kopien eines neuen angegebenen Wertelements in einen Vektor ein.

Beispiel

/ vector_assign.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> v1, v2, v3;

    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(30);
    v1.push_back(40);
    v1.push_back(50);

    cout << "v1 = ";
    for (auto& v : v1){
        cout << v << " ";
    }
    cout << endl;

    v2.assign(v1.begin(), v1.end());
    cout << "v2 = ";
    for (auto& v : v2){
        cout << v << " ";
    }
    cout << endl;

    v3.assign(7, 4);
    cout << "v3 = ";
    for (auto& v : v3){
        cout << v << " ";
    }
    cout << endl;

    v3.assign({ 5, 6, 7 });
    for (auto& v : v3){
        cout << v << " ";
    }
    cout << endl;
}

`at`

Gibt einen Verweis auf das Element an einer angegebenen Position in dem Vektor zurück.

reference at(size_type position);

const_reference at(size_type position) const;

Parameter

position
Dier Feldindex oder Positionsnummer des Elements, das auf den Vektor verweisen soll.

Rückgabewert

Ein Verweis auf das Element, das im Argument indiziert ist. Wenn position die Größe des Vektors größer ist, at wird eine Ausnahme ausgelöst.

Hinweise

Wenn der Rückgabewert at eines const_referenceObjekts zugewiesen ist, kann das Vektorobjekt nicht geändert werden. Wenn at dem Rückgabewert von reference zugewiesen wird, kann das Vektorobjekt geändert werden.

Beispiel

// vector_at.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   const int &i = v1.at( 0 );
   int &j = v1.at( 1 );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}

The first element is 10
The second element is 20

`back`

Gibt einen Verweis auf das letzte Element des Vektors zurück.

reference back();

const_reference back() const;

Rückgabewert

Das letzte Element des Vektors. Wenn der Vektor leer ist, ist der Rückgabewert nicht definiert.

Hinweise

Wenn der Rückgabewert back eines const_referenceObjekts zugewiesen ist, kann das Vektorobjekt nicht geändert werden. Wenn back dem Rückgabewert von reference zugewiesen wird, kann das Vektorobjekt geändert werden.

Bei der Kompilierung mithilfe _ITERATOR_DEBUG_LEVEL von 1 oder 2 tritt ein Laufzeitfehler auf, wenn Sie versuchen, auf ein Element in einem leeren Vektor zuzugreifen. Weitere Informationen finden Sie unter Überprüfte Iteratoren.

Beispiel

// vector_back.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main() {
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 11 );

   int& i = v1.back( );
   const int& ii = v1.front( );

   cout << "The last integer of v1 is " << i << endl;
   i--;
   cout << "The next-to-last integer of v1 is "<< ii << endl;
}

`begin`

Gibt einen Iterator mit wahlfreiem Zugriff für das erste Element im Vektor zurück.

const_iterator begin() const;

iterator begin();

Rückgabewert

Ein Iterator mit direktem Zugriff, der das erste Element im vector adressiert oder auf die Position zeigt, der auf einen leeren vector folgt. Vergleichen Sie immer den zurückgegebenen Wert, vector::end um sicherzustellen, dass er gültig ist.

Hinweise

Wenn der Rückgabewert begin eines vector::const_iteratorObjekts zugewiesen ist, kann das vector Objekt nicht geändert werden. Wenn der Rückgabewert begin eines vector::iteratorObjekts zugewiesen ist, kann das vector Objekt geändert werden.

Beispiel

// vector_begin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> c1;
    vector<int>::iterator c1_Iter;
    vector<int>::const_iterator c1_cIter;

    c1.push_back(1);
    c1.push_back(2);

    cout << "The vector c1 contains elements:";
    c1_Iter = c1.begin();
    for (; c1_Iter != c1.end(); c1_Iter++)
    {
        cout << " " << *c1_Iter;
    }
    cout << endl;

    cout << "The vector c1 now contains elements:";
    c1_Iter = c1.begin();
    *c1_Iter = 20;
    for (; c1_Iter != c1.end(); c1_Iter++)
    {
        cout << " " << *c1_Iter;
    }
    cout << endl;

    // The following line would be an error because iterator is const
    // *c1_cIter = 200;
}

The vector c1 contains elements: 1 2
The vector c1 now contains elements: 20 2

`capacity`

Gibt die Anzahl von Elementen zurück, die der Vektor enthalten kann, ohne zusätzlichen Speicher zuzuweisen.

size_type capacity() const;

Rückgabewert

Die aktuelle Speicherlänge, die für den Vektor zugewiesen wurde.

Hinweise

Die Memberfunktion resize wird effizienter sein, wenn genügend Arbeitsspeicher zugeordnet ist, um sie aufzunehmen. Verwenden Sie die Memberfunktion reserve , um die Menge des zugeordneten Arbeitsspeichers anzugeben.

Beispiel

// vector_capacity.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 1 );
   cout << "The length of storage allocated is "
        << v1.capacity( ) << "." << endl;

   v1.push_back( 2 );
   cout << "The length of storage allocated is now "
        << v1.capacity( ) << "." << endl;
}

The length of storage allocated is 1.
The length of storage allocated is now 2.

`cbegin`

Gibt einen const-Iterator zurück, mit dem das erste Element im Bereich behandelt wird.

const_iterator cbegin() const;

Rückgabewert

Ein const-Random-Access-Iterator, der auf das erste Element des Bereichs zeigt oder die Position direkt hinter dem Ende eines leeren Bereichs (für einen leeren Bereich gilt cbegin() == cend()).

Hinweise

Mit dem Rückgabewert von cbegin, die Elemente im Bereich können nicht geändert werden.

Sie können diese Memberfunktion anstelle der begin()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. Normalerweise wird sie mit dem auto Stichwort "Typabzug" verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein beliebiger änderbarer (Nicht-const-)Container, der begin() und cbegin() unterstützt.

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`cend`

Gibt einen const Past-the-End-Iterator zurück, der auf das Element verweist, das auf das letzte Element des Vektors folgt.

const_iterator cend() const;

Rückgabewert

Ein const Past-the-End-Iterator für den Vektor. Es verweist auf das Element, das auf das letzte Element des Vektors folgt. Dieses Element ist ein Platzhalter und sollte nicht abgeleitet werden. Verwenden Sie es nur für Vergleiche. Wenn der Vektor leer ist, dann vector::cend() == vector::cbegin().

Hinweise

cend wird verwendet, um zu testen, ob ein Iterator das Ende seines Bereichs übergeben hat.

Sie können diese Memberfunktion anstelle der end()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. In der Regel wird sie mit dem auto Stichwort "Typabzug" verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein beliebiger änderbarer (Nicht-const-)Container, der end() und cend() unterstützt.

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

Der zurückgegebene cend Wert sollte nicht abgeleitet werden. Verwenden Sie es nur für Vergleiche.

`clear`

Löscht die Elemente des Vektors.

void clear();

Beispiel

// vector_clear.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "The size of v1 is " << v1.size( ) << endl;
   v1.clear( );
   cout << "The size of v1 after clearing is " << v1.size( ) << endl;
}

The size of v1 is 3
The size of v1 after clearing is 0

`const_iterator`

Ein Typ, der einen Iterator mit wahlfreiem Zugriff bereitstellt, mit dem ein const-Element in einem Vektor gelesen werden kann.

typedef implementation-defined const_iterator;

Hinweise

Ein Typ const_iterator kann nicht verwendet werden, um den Wert eines Elements zu ändern.

Beispiel

In dem Beispiel für back finden Sie ein Beispiel, in dem const_iterator verwendet wird.

`const_pointer`

Ein Typ, der einen Zeiger auf ein const-Element in einem Vektor bereitstellt.

typedef typename Allocator::const_pointer const_pointer;

Hinweise

Ein Typ const_pointer kann nicht verwendet werden, um den Wert eines Elements zu ändern.

Ein Iterator wird häufiger für den Zugriff auf ein Vektorelement verwendet.

`const_reference`

Ein Typ, der einen Verweis auf ein const element bereitstellt, das in einem Vektor gespeichert ist. Sie wird zum Lesen und Ausführen von const Vorgängen verwendet.

typedef typename Allocator::const_reference const_reference;

Hinweise

Ein Typ const_reference kann nicht verwendet werden, um den Wert eines Elements zu ändern.

Beispiel

// vector_const_ref.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   const vector <int> v2 = v1;
   const int &i = v2.front( );
   const int &j = v2.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;

   // The following line would cause an error as v2 is const
   // v2.push_back( 30 );
}

The first element is 10
The second element is 20

`const_reverse_iterator`

Ein Typ, der einen Iterator mit zufälligem Zugriff bereitstellt, mit dem jedes const-Element im Vektor gelesen werden kann.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Hinweise

Ein Typ const_reverse_iterator kann den Wert eines Elements nicht ändern und wird verwendet, um den Vektor umgekehrt zu durchlaufen.

Beispiel

Hier finden Sie rbegin ein Beispiel zum Deklarieren und Verwenden eines Iterators.

`crbegin`

Gibt einen const-Iterator zum ersten Element in einem umgekehrten Vektor zurück.

const_reverse_iterator crbegin() const;

Rückgabewert

Ein umgekehrter Iterator für zufälligen Zugriff, der das erste Element in einem umgekehrten vector Element adressiert oder angibt, was das letzte Element in der unreversierten vector.

Hinweise

Mit dem Rückgabewert des crbeginObjekts kann das vector Objekt nicht geändert werden.

Beispiel

// vector_crbegin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;
   vector <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of vector is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.crbegin( );
   cout << "The first element of the reversed vector is "
        << *v1_rIter << "." << endl;
}

The first element of vector is 1.
The first element of the reversed vector is 2.

`crend`

Gibt einen const umgekehrten Umgekehrten Iterator zurück, der auf das Element nach dem letzten Element des umgekehrten Vektors zeigt.

const_reverse_iterator crend() const;

Rückgabewert

Ein umgekehrter const Past-the-End-Iterator für den umgekehrten Vektor. Es verweist auf das Element nach dem letzten Element des umgekehrten Vektors, das dem Element vor dem ersten Element des nicht umgekehrten Vektors entspricht. Dieses Element ist ein Platzhalter und sollte nicht abgeleitet werden. Verwenden Sie es nur für Vergleiche.

Hinweise

crend wird mit einem umgekehrten vector verwendet, genau wie vector::cend bei einem vector.

Mit dem Rückgabewert ( crend entsprechend dekrementiert) kann das vector Objekt nicht geändert werden.

crend kann verwendet werden, um zu testen, ob das Ende der vector von einem umgekehrten Iterator erreicht wurde.

Der zurückgegebene crend Wert sollte nicht abgeleitet werden. Verwenden Sie es nur für Vergleiche.

Beispiel

// vector_crend.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`data`

Gibt einen Zeiger auf das erste Element im Vektor zurück.

const_pointer data() const;

pointer data();

Rückgabewert

Ein Zeiger auf das erste Element in der vector oder an der Position, an der ein leeres Element erfolgreich vectorwar.

Beispiel

// vector_data.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> c1;
    vector<int>::pointer c1_ptr;
    vector<int>::const_pointer c1_cPtr;

    c1.push_back(1);
    c1.push_back(2);

    cout << "The vector c1 contains elements:";
    c1_cPtr = c1.data();
    for (size_t n = c1.size(); 0 < n; --n, c1_cPtr++)
    {
        cout << " " << *c1_cPtr;
    }
    cout << endl;

    cout << "The vector c1 now contains elements:";
    c1_ptr = c1.data();
    *c1_ptr = 20;
    for (size_t n = c1.size(); 0 < n; --n, c1_ptr++)
    {
        cout << " " << *c1_ptr;
    }
    cout << endl;
}

The vector c1 contains elements: 1 2
The vector c1 now contains elements: 20 2

`difference_type`

Ein Typ, der den Unterschied zwischen zwei Iteratoren, die auf Elemente innerhalb desselben Vektors verweisen, bereitstellt.

typedef typename Allocator::difference_type difference_type;

Hinweise

Ein difference_type kann auch als die Anzahl von Elementen zwischen zwei Zeigern beschrieben werden, da ein Zeiger auf ein Element die entsprechende Adresse enthält.

Ein Iterator wird häufiger für den Zugriff auf ein Vektorelement verwendet.

Beispiel

// vector_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <vector>
#include <algorithm>

int main( )
{
   using namespace std;

   vector <int> c1;
   vector <int>::iterator c1_Iter, c2_Iter;

   c1.push_back( 30 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 10 );
   c1.push_back( 30 );
   c1.push_back( 20 );

   c1_Iter = c1.begin( );
   c2_Iter = c1.end( );

   vector <int>::difference_type   df_typ1, df_typ2, df_typ3;

   df_typ1 = count( c1_Iter, c2_Iter, 10 );
   df_typ2 = count( c1_Iter, c2_Iter, 20 );
   df_typ3 = count( c1_Iter, c2_Iter, 30 );
   cout << "The number '10' is in c1 collection " << df_typ1 << " times.\n";
   cout << "The number '20' is in c1 collection " << df_typ2 << " times.\n";
   cout << "The number '30' is in c1 collection " << df_typ3 << " times.\n";
}

The number '10' is in c1 collection 1 times.
The number '20' is in c1 collection 2 times.
The number '30' is in c1 collection 3 times.

`emplace`

Fügt ein direkt konstruiertes Element an einer angegebenen Position in den Vektor ein.

template <class... Types>
iterator emplace(
    const_iterator position,
    Types&&... args);

Parameter

position
Die Position, an der vector das erste Element eingefügt wird.

args
Konstruktorargumente Die Funktion leitet auf Grundlage der bereitgestellten Argumente die erforderliche die Konstruktorüberladung ab.

Rückgabewert

Die Funktion gibt einen Iterator zurück, der auf den Speicherort zeigt, an dem das neue Element in den vector eingefügt wurde.

Hinweise

Jeder Einfügevorgang kann teuer sein, siehe vector Klasse für eine Erläuterung der vector Leistung.

Beispiel

// vector_emplace.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

// initialize a vector of vectors by moving v1
   vector < vector <int> > vv1;

   vv1.emplace( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
}

v1 = 10 20 30
vv1[0] = 10 20 30

`emplace_back`

Fügt ein direkt konstruiertes Element am Ende des Vektors ein.

template <class... Types>
void emplace_back(Types&&... args);

Parameter

args
Konstruktorargumente Die Funktion leitet auf Grundlage der bereitgestellten Argumente die erforderliche die Konstruktorüberladung ab.

Beispiel

#include <vector>
struct obj
{
   obj(int, double) {}
};

int main()
{
   std::vector<obj> v;
   v.emplace_back(1, 3.14); // obj in created in place in the vector
}

`empty`

Testet, ob der Vektor leer ist.

bool empty() const;

Rückgabewert

true wenn der Vektor leer ist; false wenn der Vektor nicht leer ist.

Beispiel

// vector_empty.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );

   if ( v1.empty( ) )
      cout << "The vector is empty." << endl;
   else
      cout << "The vector is not empty." << endl;
}

The vector is not empty.

`end`

Gibt einen Past-the-End-Iterator zurück, der auf das Element verweist, das auf das letzte Element des Vektors folgt.

iterator end();

const_iterator end() const;

Rückgabewert

Ein Past-the-End-Iterator für den Vektor. Es verweist auf das Element, das auf das letzte Element des Vektors folgt. Dieses Element ist ein Platzhalter und sollte nicht abgeleitet werden. Verwenden Sie es nur für Vergleiche. Wenn der Vektor leer ist, dann vector::end() == vector::begin().

Hinweise

Wenn der Rückgabewert end einer Variablen vom Typ const_iteratorzugewiesen ist, kann das Vektorobjekt nicht geändert werden. Wenn der Rückgabewert end einer Variablen vom Typ iteratorzugewiesen ist, kann das Vektorobjekt geändert werden.

Beispiel

// vector_end.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>
int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_Iter = v1.begin( ) ; v1_Iter != v1.end( ) ; v1_Iter++ )
      cout << *v1_Iter << endl;
}

1
2

`erase`

Entfernt ein Element oder eine Reihe von Elementen aus angegebenen Positionen in einem Vektor.

iterator erase(
    const_iterator position);

iterator erase(
    const_iterator first,
    const_iterator last);

Parameter

position
Die Position des von dem Vektor zu entfernenden Elements.

first
Die Position des ersten Elements, das von dem Vektor entfernt werden soll.

last
Die Position direkt hinter dem letzten von dem Vektor entfernten Element.

Rückgabewert

Ein Iterator, der das erste über die entfernten Elemente hinaus verbliebene Element festlegt, oder ein Zeiger, der das Ende des Vektors darstellt, wenn kein solches Element vorhanden ist.

Beispiel

// vector_erase.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );
   v1.push_back( 40 );
   v1.push_back( 50 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.erase( v1.begin( ) );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.erase( v1.begin( ) + 1, v1.begin( ) + 3 );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
}

v1 = 10 20 30 40 50
v1 = 20 30 40 50
v1 = 20 50

`front`

Gibt einen Verweis auf das erste Element in einem Vektor zurück.

reference front();

const_reference front() const;

Rückgabewert

Ein Verweis auf das erste Element im Vektorobjekt. Wenn der Vektor leer ist, ist die Rückgabe nicht definiert.

Hinweise

Wenn der Rückgabewert front eines const_referenceObjekts zugewiesen ist, kann das Vektorobjekt nicht geändert werden. Wenn front dem Rückgabewert von reference zugewiesen wird, kann das Vektorobjekt geändert werden.

Beispiel

// vector_front.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 11 );

   int& i = v1.front( );
   const int& ii = v1.front( );

   cout << "The first integer of v1 is "<< i << endl;
   // by incrementing i, we move the front reference to the second element
   i++;
   cout << "Now, the first integer of v1 is "<< i << endl;
}

`get_allocator`

Gibt eine Kopie des Zuweisungsobjekts zurück, das zum Erstellen eines Vektors verwendet wird.

Allocator get_allocator() const;

Rückgabewert

Die von dem Vektor verwendete Zuweisung.

Hinweise

Zuweisungen für die Vektorklasse geben an, wie die Klasse einen Speicher verwaltet. Für die meisten Programmieranforderungen reichen die standardmäßigen allocator-Objekte mit Container-Klassen der C++-Standardbibliothek aus. Das Schreiben und Verwenden Ihrer eigenen Allocator-Klasse ist ein erweitertes C++-Feature.

Beispiel

// vector_get_allocator.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   // The following lines declare objects that use the default allocator.
   vector<int> v1;
   vector<int, allocator<int> > v2 = vector<int, allocator<int> >(allocator<int>( )) ;

   // v3 will use the same allocator class as v1
   vector <int> v3( v1.get_allocator( ) );

   vector<int>::allocator_type xvec = v3.get_allocator( );
   // You can now call functions on the allocator class used by vec
}

`insert`

Fügt ein Element oder viele Elemente oder einen Bereich von Elementen an einer angegebenen Position in den Vektor ein.

iterator insert(
    const_iterator position,
    const Type& value);

iterator insert(
    const_iterator position,
    Type&& value);

void insert(
    const_iterator position,
    size_type count,
    const Type& value);

template <class InputIterator>
void insert(
    const_iterator position,
    InputIterator first,
    InputIterator last);

Parameter

position
Die Position in dem Vektor, an der das erste Element eingefügt wird.

value
Der Wert des Elements, das in den Vektor eingefügt wird.

count
Die Anzahl von Elementen, die in den Vektor eingefügt werden.

first
Die Position des ersten Elements in dem zu kopierenden Elementbereich.

last
Die Position des ersten Elements nach dem zu kopierenden Elementbereich.

Rückgabewert

Die ersten zwei insert-Funktionen geben einen Iterator zurück, der auf den Speicherort zeigt, an dem das neue Element in den Vektor eingefügt wurde.

Hinweise

Als Vorbedingung gilt, dass first und last keine Iteratoren für den Vektor sein dürfen, da sonst das Verhalten nicht definiert ist. Jeder Einfügevorgang kann teuer sein, siehe vector Klasse für eine Erläuterung der vector Leistung.

Beispiel

// vector_insert.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.insert( v1.begin( ) + 1, 40 );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
   v1.insert( v1.begin( ) + 2, 4, 50 );

   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   const auto v2 = v1;
   v1.insert( v1.begin( )+1, v2.begin( )+2, v2.begin( )+4 );
   cout << "v1 =";
   for (Iter = v1.begin( ); Iter != v1.end( ); Iter++ )
      cout << " " << *Iter;
   cout << endl;

// initialize a vector of vectors by moving v1
   vector < vector <int> > vv1;

   vv1.insert( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
}

v1 = 10 20 30
v1 = 10 40 20 30
v1 = 10 40 50 50 50 50 20 30
v1 = 10 50 50 40 50 50 50 50 20 30
vv1[0] = 10 50 50 40 50 50 50 50 20 30

`iterator`

Ein Typ, der einen Iterator mit wahlfreiem Zugriff bereitstellt, mit dem jedes Element in einem Vektor gelesen oder geändert werden kann.

typedef implementation-defined iterator;

Hinweise

Ein Typ iterator kann verwendet werden, um den Wert eines Elements zu ändern.

Beispiel

Ein Beispiel hierfür finden Sie unter begin.

`max_size`

Gibt die Maximallänge des Vektors zurück.

size_type max_size() const;

Rückgabewert

Die mögliche Maximallänge des Vektors.

Beispiel

// vector_max_size.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::size_type i;

   i = v1.max_size( );
   cout << "The maximum possible length of the vector is " << i << "." << endl;
}

`operator[]`

Gibt einen Verweis auf das Vektorelement an einer angegebenen Position zurück.

reference operator[](size_type position);

const_reference operator[](size_type position) const;

Parameter

position
Die Position des angegebenen Vektorelements.

Rückgabewert

Wenn die angegebene Position größer oder gleich der Größe des Containers ist, ist das Ergebnis nicht definiert.

Hinweise

Wenn der Rückgabewert operator[] eines const_referenceObjekts zugewiesen ist, kann das Vektorobjekt nicht geändert werden. Wenn der Rückgabewert von operator[] einem Verweis zugewiesen wird, kann das Vektorobjekt geändert werden.

Bei der Kompilierung mithilfe _ITERATOR_DEBUG_LEVEL von 1 oder 2 tritt ein Laufzeitfehler auf, wenn Sie versuchen, auf ein Element außerhalb der Grenzen des Vektors zuzugreifen. Weitere Informationen finden Sie unter Überprüfte Iteratoren.

Beispiel

// vector_op_ref.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   int& i = v1[1];
   cout << "The second integer of v1 is " << i << endl;
}

`operator=`

Ersetzt die Elemente des Vektors durch eine Kopie eines anderen Vektors.

vector& operator=(const vector& right);

vector& operator=(vector&& right);

Parameter

right
Das vector kopierte In das vector.

Hinweise

Nachdem ein vorhandenes Element in einem vector gelöscht wurde, kopiert oder verschiebt operator= den Inhalt von right in den vector.

Beispiel

// vector_operator_as.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector<int> v1, v2, v3;
   vector<int>::iterator iter;

   v1.push_back(10);
   v1.push_back(20);
   v1.push_back(30);
   v1.push_back(40);
   v1.push_back(50);

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << *iter << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;
}

`pointer`

Ein Typ, der einen Zeiger auf ein Element in einem Vektor bereitstellt.

typedef typename Allocator::pointer pointer;

Hinweise

Ein Typ pointer kann verwendet werden, um den Wert eines Elements zu ändern.

Beispiel

// vector_pointer.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
    using namespace std;
    vector<int> v;
    v.push_back( 11 );
    v.push_back( 22 );

    vector<int>::pointer ptr = &v[0];
    cout << *ptr << endl;
    ptr++;
    cout << *ptr << endl;
    *ptr = 44;
    cout << *ptr << endl;
}

11
22
44

`pop_back`

Löscht das Element am Ende des Vektors.

void pop_back();

Hinweise

Ein Codebeispiel finden Sie unter vector::push_back().

`push_back`

Fügt ein Element am Ende des Vektors hinzu.

void push_back(const T& value);

void push_back(T&& value);

Parameter

value
Der Wert, der dem am Ende des Vektors hinzugefügten Element zugewiesen werden soll.

Beispiel

// compile with: /EHsc /W4
#include <vector>
#include <iostream>

using namespace std;

template <typename T> void print_elem(const T& t) {
    cout << "(" << t << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << "  " << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

int main()
{
    vector<int> v;
    for (int i = 0; i < 10; ++i) {
        v.push_back(10 + i);
    }

    cout << "vector data: " << endl;
    print_collection(v);

    // pop_back() until it's empty, printing the last element as we go
    while (v.begin() != v.end()) {
        cout << "v.back(): "; print_elem(v.back()); cout << endl;
        v.pop_back();
    }
}

`rbegin`

Gibt einen Iterator an das erste Element in einem umgekeherten Vektor zurück.

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

Rückgabewert

Ein umgekehrter Iterator mit direktem Zugriff, mit dem das erste Element in einem umgekehrten Vektor adressiert wird (bzw. mit dem das ehemals letzte Element in der nicht umgekehrten Vektor adressiert wird).

Hinweise

Wenn der Rückgabewert rbegin eines const_reverse_iteratorObjekts zugewiesen ist, kann das Vektorobjekt nicht geändert werden. Wenn rbegin dem Rückgabewert von reverse_iterator zugewiesen wird, kann das Vektorobjekt geändert werden.

Beispiel

// vector_rbegin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;
   vector <int>::reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of vector is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.rbegin( );
   cout << "The first element of the reversed vector is "
        << *v1_rIter << "." << endl;
}

The first element of vector is 1.
The first element of the reversed vector is 2.

`reference`

Ein Typ, der einen Verweis auf ein in einem Vektor gespeichertes Element bereitstellt.

typedef typename Allocator::reference reference;

Beispiel

Sehen Sie at sich ein Beispiel für die Verwendung reference in der Vektorklasse an.

`rend`

Gibt einen umgekehrten Umgekehrten Iterator zurück, der auf das Element nach dem letzten Element des umgekehrten Vektors zeigt.

const_reverse_iterator rend() const;
reverse_iterator rend();

Rückgabewert

Ein umgekehrter Past-the-End-Iterator für den umgekehrten Vektor. Es verweist auf das Element nach dem letzten Element des umgekehrten Vektors, das dem Element vor dem ersten Element des nicht umgekehrten Vektors entspricht. Dieses Element ist ein Platzhalter und sollte nicht abgeleitet werden. Verwenden Sie es nur für Vergleiche.

Hinweise

rend wird mit einem umgekehrten Vektor wie end bei einem Vektor verwendet.

Wenn der Rückgabewert rend eines const_reverse_iteratorObjekts zugewiesen ist, kann das Vektorobjekt nicht geändert werden. Wenn rend dem Rückgabewert von reverse_iterator zugewiesen wird, kann das Vektorobjekt geändert werden.

rend kann verwendet werden, um zu testen, ob das Ende des Vektors von einem umgekehrten Iterator erreicht wurde.

Der zurückgegebene rend Wert sollte nicht abgeleitet werden. Verwenden Sie es nur für Vergleiche.

Beispiel

// vector_rend.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`reserve`

Reserviert eine Mindestlänge von Speicher für ein Vektorobjekt und weist Speicherplatz zu, falls erforderlich.

void reserve(size_type count);

Parameter

count
Die minimale Speicherlänge, die für für den Vektor zugeordnet werden soll.

Beispiel

// vector_reserve.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   //vector <int>::iterator Iter;

   v1.push_back( 1 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.reserve( 20 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
}

Current capacity of v1 = 1
Current capacity of v1 = 20

`resize`

Gibt eine neue Größe für einen Vektor an.

void resize(size_type new_size);
void resize(size_type new_size, Type value);

Parameter

new_size
Die neue Größe des Vektors.

value
Der Initialisierungswert für neue Elemente, der zum Vektor hinzugefügt wird, wenn die neue Größe die Originalgröße übersteigt. Wenn der Wert ausgelassen wird, verwenden die neuen Objekte ihren Standardkonstruktor.

Hinweise

Wenn die Größe des Containers kleiner als die angeforderte Größe ist, werden dem Vektor Elemente hinzugefügt, new_sizeresize bis sie die angeforderte Größe erreicht. Wenn die Größe des Containers größer als die angeforderte Größe ist, werden die Elemente gelöscht, die am Ende des Containers am nächsten sind, resize bis sie die Größe new_sizeerreicht. Es wird keine Aktion ausgeführt, wenn die aktuelle Größe des Containers mit der angeforderten Größe übereinstimmt.

size gibt die aktuelle Größe des Vektors wieder.

Beispiel

// vectorsizing.cpp
// compile with: /EHsc /W4
// Illustrates vector::reserve, vector::max_size,
// vector::resize, vector::resize, and vector::capacity.
//
// Functions:
//
//    vector::max_size - Returns maximum number of elements vector could
//                       hold.
//
//    vector::capacity - Returns number of elements for which memory has
//                       been allocated.
//
//    vector::size - Returns number of elements in the vector.
//
//    vector::resize - Reallocates memory for vector, preserves its
//                     contents if new size is larger than existing size.
//
//    vector::reserve - Allocates elements for vector to ensure a minimum
//                      size, preserving its contents if the new size is
//                      larger than existing size.
//
//    vector::push_back - Appends (inserts) an element to the end of a
//                        vector, allocating memory for it if necessary.
//
//////////////////////////////////////////////////////////////////////

// The debugger cannot handle symbols more than 255 characters long.
// The C++ Standard Library often creates symbols longer than that.
// The warning can be disabled:
//#pragma warning(disable:4786)

#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename C> void print(const string& s, const C& c) {
    cout << s;

    for (const auto& e : c) {
        cout << e << " ";
    }
    cout << endl;
}

void printvstats(const vector<int>& v) {
    cout << "   the vector's size is: " << v.size() << endl;
    cout << "   the vector's capacity is: " << v.capacity() << endl;
    cout << "   the vector's maximum size is: " << v.max_size() << endl;
}

int main()
{
    // declare a vector that begins with 0 elements.
    vector<int> v;

    // Show statistics about vector.
    cout << endl << "After declaring an empty vector:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    // Add one element to the end of the vector.
    v.push_back(-1);
    cout << endl << "After adding an element:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    for (int i = 1; i < 10; ++i) {
        v.push_back(i);
    }
    cout << endl << "After adding 10 elements:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(6);
    cout << endl << "After resizing to 6 elements without an initialization value:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(9, 999);
    cout << endl << "After resizing to 9 elements with an initialization value of 999:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(12);
    cout << endl << "After resizing to 12 elements without an initialization value:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    // Ensure there's room for at least 1000 elements.
    v.reserve(1000);
    cout << endl << "After vector::reserve(1000):" << endl;
    printvstats(v);

    // Ensure there's room for at least 2000 elements.
    v.resize(2000);
    cout << endl << "After vector::resize(2000):" << endl;
    printvstats(v);
}

`reverse_iterator`

Ein Typ, der einen Iterator mit zufälligem Zugriff bereitstellt, mit dem jedes Element in einem umgekehrten Vektor gelesen oder geändert werden kann.

typedef std::reverse_iterator<iterator> reverse_iterator;

Hinweise

Ein reverse_iterator-Typ wird verwendet, um den Vektor in umgekehrter Reihenfolge zu durchlaufen.

Beispiel

Ein Beispiel hierfür finden Sie unter rbegin.

`shrink_to_fit`

Verwirft Überkapazität.

void shrink_to_fit();

Beispiel

// vector_shrink_to_fit.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   //vector <int>::iterator Iter;

   v1.push_back( 1 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.reserve( 20 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.shrink_to_fit();
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
}

Current capacity of v1 = 1
Current capacity of v1 = 20
Current capacity of v1 = 1

`size`

Gibt die Anzahl von Elementen in dem Vektor zurück.

size_type size() const;

Rückgabewert

Die aktuelle Länge des Vektors.

Beispiel

// vector_size.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::size_type i;

   v1.push_back( 1 );
   i = v1.size( );
   cout << "Vector length is " << i << "." << endl;

   v1.push_back( 2 );
   i = v1.size( );
   cout << "Vector length is now " << i << "." << endl;
}

Vector length is 1.
Vector length is now 2.

`size_type`

Ein Typ, der die Anzahl von Elementen in einem Vektor zählt.

typedef typename Allocator::size_type size_type;

Beispiel

Ein Beispiel hierfür finden Sie unter capacity.

`swap`

Tauscht die Elemente zweier Vektoren aus.

void swap(
    vector<Type, Allocator>& right);

friend void swap(
    vector<Type, Allocator>& left,
    vector<Type, Allocator>& right);

Parameter

right
Ein Vektor, der die zu tauschenden Elemente bereitstellt. Oder ein Vektor, dessen Elemente mit den Elementen im Vektor leftausgetauscht werden sollen.

left
Ein Vektor, dessen Elemente mit den Elementen im Vektor rightausgetauscht werden sollen.

Beispiel

// vector_swap.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1, v2;

   v1.push_back( 1 );
   v1.push_back( 2 );
   v1.push_back( 3 );

   v2.push_back( 10 );
   v2.push_back( 20 );

   cout << "The number of elements in v1 = " << v1.size( ) << endl;
   cout << "The number of elements in v2 = " << v2.size( ) << endl;
   cout << endl;

   v1.swap( v2 );

   cout << "The number of elements in v1 = " << v1.size( ) << endl;
   cout << "The number of elements in v2 = " << v2.size( ) << endl;
}

The number of elements in v1 = 3
The number of elements in v2 = 2

The number of elements in v1 = 2
The number of elements in v2 = 3

`value_type`

Ein Typ, der den in einem Vektor gespeicherten Datentyp darstellt.

typedef typename Allocator::value_type value_type;

Hinweise

value_type ist ein Synonym für den Vorlagenparameter Type.

Beispiel

// vector_value_type.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector<int>::value_type AnInt;
   AnInt = 44;
   cout << AnInt << endl;
}

`vector`

Erstellt einen Vektor. Überladungen erstellen einen Vektor einer bestimmten Größe oder mit Elementen eines bestimmten Werts. Oder als Kopie aller oder eines Teils eines anderen Vektors. Bei einigen Überladungen können Sie auch den zu verwendenden Allocator angeben.

vector();
explicit vector(const Allocator& allocator);
explicit vector(size_type count);
vector(size_type count, const Type& value);
vector(size_type count, const Type& value, const Allocator& allocator);

vector(const vector& source);
vector(vector&& source);
vector(initializer_list<Type> init_list, const Allocator& allocator);

template <class InputIterator>
vector(InputIterator first, InputIterator last);
template <class InputIterator>
vector(InputIterator first, InputIterator last, const Allocator& allocator);

Parameter

allocator
Die mit diesem Objekt zu verwendende Zuweisungsklasse. get_allocator gibt die Allocator-Klasse für das Objekt zurück.

count
Die Anzahl der Elemente im erstellten Vektor.

value
Der Wert der Elemente im erstellten Vektor.

source
Der Vektor, dessen Kopie der erstellte Vektor ist.

first
Die Position des ersten Elements in dem zu kopierenden Elementbereich.

last
Die Position des ersten Elements nach dem zu kopierenden Elementbereich.

init_list
Die initializer_list elemente, die kopiert werden sollen.

Hinweise

Alle Konstruktoren speichern ein Allocator-Objekt (allocator) und initialisieren den Vektor.

Die ersten beiden Konstruktoren geben einen leeren ursprünglichen Vektor an. Der zweite Konstruktor gibt explizit den zu verwendenden Allocatortyp (allocator) an.

Der dritte Konstruktor gibt eine Wiederholung einer angegebenen Anzahl (count) von Elementen des Standardwerts für die Klasse Type an.

Die vierten und fünften Konstruktoren geben eine Wiederholung von (count) Elementen des Werts valuean.

Der sechste Konstruktor gibt eine Kopie des Vektors source an.

Mit dem siebten Konstruktor wird der source-Vektor verschoben.

Beim achten Konstruktor wird zum Angeben des Elements ein initializer_list-Element verwendet.

Mit den neunten und zehnten Konstruktoren wird der Bereich [first, last) eines Vektors kopiert.

Beispiel

// vector_ctor.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector <int>::iterator v1_Iter, v2_Iter, v3_Iter, v4_Iter, v5_Iter, v6_Iter;

    // Create an empty vector v0
    vector <int> v0;

    // Create a vector v1 with 3 elements of default value 0
    vector <int> v1(3);

    // Create a vector v2 with 5 elements of value 2
    vector <int> v2(5, 2);

    // Create a vector v3 with 3 elements of value 1 and with the allocator
    // of vector v2
    vector <int> v3(3, 1, v2.get_allocator());

    // Create a copy, vector v4, of vector v2
    vector <int> v4(v2);

    // Create a new temporary vector for demonstrating copying ranges
    vector <int> v5(5);
    for (auto i : v5) {
        v5[i] = i;
    }

    // Create a vector v6 by copying the range v5[ first,  last)
    vector <int> v6(v5.begin() + 1, v5.begin() + 3);

    cout << "v1 =";
    for (auto& v : v1){
        cout << " " << v;
    }
    cout << endl;

    cout << "v2 =";
    for (auto& v : v2){
        cout << " " << v;
    }
    cout << endl;

    cout << "v3 =";
    for (auto& v : v3){
        cout << " " << v;
    }
    cout << endl;
    cout << "v4 =";
    for (auto& v : v4){
        cout << " " << v;
    }
    cout << endl;

    cout << "v5 =";
    for (auto& v : v5){
        cout << " " << v;
    }
    cout << endl;

    cout << "v6 =";
    for (auto& v : v6){
        cout << " " << v;
    }
    cout << endl;

    // Move vector v2 to vector v7
    vector <int> v7(move(v2));
    vector <int>::iterator v7_Iter;

    cout << "v7 =";
    for (auto& v : v7){
        cout << " " << v;
    }
    cout << endl;

    cout << "v8 =";
    vector<int> v8{ { 1, 2, 3, 4 } };
    for (auto& v : v8){
        cout << " " << v ;
    }
    cout << endl;
}

v1 = 0 0 0
v2 = 2 2 2 2 2
v3 = 1 1 1
v4 = 2 2 2 2 2
v5 = 0 0 0 0 0
v6 = 0 0
v7 = 2 2 2 2 2
v8 = 1 2 3 4

Siehe auch

Threadsicherheit in der C++-Standardbibliothek
C++-Standardbibliotheksreferenz

Freigeben über

vector-Klasse

Syntax

Parameter

Hinweise

Member

Konstruktoren

TypeDefs

Funktionen

Operatoren

allocator_type

Hinweise

Beispiel

assign

Parameter

Hinweise

Beispiel

at

Parameter

Rückgabewert

Hinweise

Beispiel

back

Rückgabewert

Hinweise

Beispiel

begin

Rückgabewert

Hinweise

Beispiel

capacity

Rückgabewert

Hinweise

Beispiel

cbegin

Rückgabewert

Hinweise

cend

Rückgabewert

Hinweise

clear

Beispiel

const_iterator

Hinweise

Beispiel

const_pointer

Hinweise

const_reference

Hinweise

Beispiel

const_reverse_iterator

Hinweise

Beispiel

crbegin

Rückgabewert

Hinweise

Beispiel

crend

Rückgabewert

Hinweise

Beispiel

data

Rückgabewert

Beispiel

difference_type

Hinweise

Beispiel

emplace

Parameter

Rückgabewert

Hinweise

Beispiel

emplace_back

Parameter

Beispiel

empty

Rückgabewert

Beispiel

end

Rückgabewert

`vector`-Klasse

`allocator_type`

`assign`

`at`

`back`

`begin`

`capacity`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`crbegin`

`crend`

`data`

`difference_type`

`emplace`

`emplace_back`

`empty`

`end`

`erase`

`front`

`get_allocator`

`insert`

`iterator`

`max_size`

`operator[]`

`operator=`

`pointer`

`pop_back`

`push_back`

`rbegin`

`reference`

`rend`

`reserve`

`resize`

`reverse_iterator`

`shrink_to_fit`

`size`

`size_type`