vector-Klasse

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 Zufallszugriffs 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>.

Bemerkungen

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 schneller bei Einfügungen und Löschungen am Anfang und Ende einer Sequenz. Der list Klassencontainer ist schneller bei Einfügungen und Löschungen an einer beliebigen Stelle innerhalb einer Sequenz.

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 des Typs bool. Es verfügt über einen Allocator 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.

Functions

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;

Bemerkungen

allocator_type ist ein Synonym für den Vorlagenparameter Allocator.

Beispiel

In dem Beispiel für get_allocator finden Sie ein Beispiel, in dem allocator_type verwendet 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.

Bemerkungen

assign Löscht zunächst alle vorhandenen Elemente in einem Vektor. Fügt dann assign entweder einen angegebenen Bereich von Elementen aus dem ursprünglichen Vektor in einen Vektor ein, oder es 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.

Bemerkungen

Wenn der Rückgabewert at einem zugewiesen const_referenceist, 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.

Bemerkungen

Wenn der Rückgabewert back einem zugewiesen const_referenceist, 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 von _ITERATOR_DEBUG_LEVEL "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 den zurückgegebenen vector::end Wert immer, um sicherzustellen, dass er gültig ist.

Bemerkungen

Wenn der Rückgabewert begin einem Objekt vector::const_iteratorzugewiesen ist, kann das vector Objekt nicht geändert werden. Wenn dem Rückgabewert begin eines Objekts vector::iteratorzugewiesen wird, 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.

Bemerkungen

Die Memberfunktion resize wird effizienter sein, wenn ausreichend Arbeitsspeicher zugewiesen wird, um sie zu berücksichtigen. Verwenden Sie die Memberfunktion reserve , um die Menge des zugewiesenen 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()).

Bemerkungen

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

Sie können diese Memberfunktion anstelle der begin()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. In der Regel wird sie mit dem auto Schlüsselwort "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 Letzten-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 nach dem letzten Element des Vektors. 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().

Bemerkungen

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 Schlüsselwort "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;

Bemerkungen

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;

Bemerkungen

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;

Bemerkungen

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;

Bemerkungen

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

Beispiel

Ein Beispiel zum Deklarieren und Verwenden eines Iterators finden Sie rbegin unter anderem.

crbegin

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

const_reverse_iterator crbegin() const;

Rückgabewert

Ein umgekehrter Zufallszugriffs-Iterator, der das erste Element in einer umgekehrten oder Adressierung des letzten Elements im unreversierten vectorvectorElement adressiert hat.

Bemerkungen

Mit dem Rückgabewert von crbegin, 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 verweist.

const_reverse_iterator crend() const;

Rückgabewert

Ein const 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.

Bemerkungen

crend wird mit einer umgekehrten vector Verwendung wie vector::cend bei einer vector.

Mit dem Rückgabewert ( crend entsprechend erhöht) 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 vectorElement erfolgreich ist.

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;

Bemerkungen

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 in der 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.

Bemerkungen

Jeder Einfügevorgang kann teuer sein, siehe vector Klasse für eine Diskussion 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 Letzten-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 nach dem letzten Element des Vektors. 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().

Bemerkungen

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.

Bemerkungen

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

Bei der Kompilierung mithilfe von _ITERATOR_DEBUG_LEVEL "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_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.

Bemerkungen

Zuweisungen für die Vektorklasse geben an, wie die Klasse einen Speicher verwaltet. Für die meisten Programmieranforderungen reichen die Standard-Zuweisungen aus C++-Standardbibliothek-Containerklassen 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.

Bemerkungen

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 Diskussion 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;

Bemerkungen

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

Beispiel

Weitere Informationen finden Sie im Beispiel für 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.

Bemerkungen

Wenn der Rückgabewert operator[] einem zugewiesen const_referenceist, 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 von _ITERATOR_DEBUG_LEVEL 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 die vector.

Bemerkungen

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;

Bemerkungen

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

Bemerkungen

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).

Bemerkungen

Wenn der Rückgabewert rbegin einem zugewiesen const_reverse_iteratorist, 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 verweist.

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.

Bemerkungen

rend wird mit einem umgekehrten Vektor verwendet, wie end es mit einem Vektor verwendet wird.

Wenn dem Rückgabewert rend eines Werts const_reverse_iteratorzugewiesen 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.

Bemerkungen

Wenn die Größe des Containers kleiner als die angeforderte Größe ist, fügt der Vektor Elemente hinzu, new_sizeresize bis die angeforderte Größe erreicht wird. Wenn die Größe des Containers größer als die angeforderte Größe ist, löscht die Elemente, die am nächsten am Ende des Containers liegen, resize bis die Größe new_sizeerreicht wird. Es wird keine Aktion ausgeführt, wenn die aktuelle Größe des Containers identisch mit der angeforderten Größe ist.

size spiegelt die aktuelle Größe des Vektors wider.

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;

Bemerkungen

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

Beispiel

Weitere Informationen finden Sie im Beispiel für 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

Weitere Informationen finden Sie im Beispiel für 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;

Bemerkungen

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;
}
44

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. Einige Überladungen ermöglichen es Ihnen auch, den zu verwendenden Allocator anzugeben.

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 Allocatorklasse 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.

Bemerkungen

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;

    vector<int> v8{ { 1, 2, 3, 4 } };
    for (auto& v : v8){
        cout << " " << v ;
    }
    cout << endl;
}
v1 = 0 0 0v2 = 2 2 2 2 2v3 = 1 1 1v4 = 2 2 2 2 2v5 = 0 1 2 3 4v6 = 1 2v7 = 2 2 2 2 21 2 3 4

Weitere Informationen

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