`vector` klass

Artikel
03/11/2025

C++ Standard Library-vektorklassen är en klassmall för sekvenscontainrar. En vektor lagrar element av en viss typ i ett linjärt arrangemang och ger snabb slumpmässig åtkomst till alla element. En vektor är den föredragna containern för en sekvens när prestanda för slumpmässig åtkomst är premium.

Syntax

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

Parametrar

Type
Den elementdatatyp som ska lagras i vektorn.

Allocator
Den typ som representerar det lagrade allokeringsobjektet som kapslar in information om vektorns allokering och frigöring av minne. Det här argumentet är valfritt och standardvärdet är allocator<Type>.

Anmärkningar

Vektorer tillåter konstanta tidsinfogningar och borttagningar i slutet av sekvensen. Infogning eller borttagning av element i mitten av en vektor kräver linjär tid. deque-klassen containern går snabbare vid infogningar och borttagningar i början och slutet av en sekvens. Containern list klass snabbare vid infogningar och borttagningar på valfri plats i en sekvens.

Omfördelning av vektorer inträffar när en medlemsfunktion måste öka sekvensen i vektorobjektet utöver den aktuella lagringskapaciteten. Andra infogningar och raderingar kan ändra olika lagringsadresser i sekvensen. I alla sådana fall blir iteratorer eller referenser som pekar på ändrade delar av sekvensen ogiltiga. Om ingen omfördelning sker är det bara iteratorer och referenser innan insättnings-/borttagningspunkten är giltiga.

Klassen vector<bool> är en fullständig specialisering av klassmallvektorn för element av typen bool. Den har en allokering för den underliggande typen som används av specialiseringen.

Referensklassen vector<bool> är en kapslad klass vars objekt kan ge referenser till element (enkla bitar) i ett vector<bool>-objekt.

Medlemmar

Konstruktörer

Namn	Beskrivning
`vector`	Konstruerar en vektor med en viss storlek eller med element av ett visst värde eller med en specifik `allocator` eller som en kopia av någon annan vektor.

Typedefs

Namn	Beskrivning
`allocator_type`	En typ som representerar klassen `allocator` för vektorobjektet.
`const_iterator`	En typ som ger en iterator med slumpmässig åtkomst som kan läsa ett `const` element i en vektor.
`const_pointer`	En typ som ger en pekare till ett `const` element i en vektor.
`const_reference`	En typ som ger en referens till ett `const` element som lagras i en vektor. Den används för att läsa och utföra `const` åtgärder.
`const_reverse_iterator`	En typ som ger en iterator med slumpmässig åtkomst som kan läsa alla `const` element i vektorn.
`difference_type`	En typ som ger skillnaden mellan adresserna för två element i en vektor.
`iterator`	En typ som ger en iterator med slumpmässig åtkomst som kan läsa eller ändra alla element i en vektor.
`pointer`	En typ som ger en pekare till ett element i en vektor.
`reference`	En typ som ger en referens till ett element som lagras i en vektor.
`reverse_iterator`	En typ som ger en iterator med slumpmässig åtkomst som kan läsa eller ändra alla element i en omvänd vektor.
`size_type`	En typ som räknar antalet element i en vektor.
`value_type`	En typ som representerar datatypen som lagras i en vektor.

Funktioner

Namn	Beskrivning
`assign`	Raderar en vektor och kopierar de angivna elementen till den tomma vektorn.
`at`	Returnerar en referens till elementet på en angiven plats i vektorn.
`back`	Returnerar en referens till det sista elementet i vektorn.
`begin`	Returnerar en iterator med slumpmässig åtkomst till det första elementet i vektorn.
`capacity`	Returnerar antalet element som vektorn kan innehålla utan att allokera mer lagringsutrymme.
`cbegin`	Returnerar en beständig iterator med slumpmässig åtkomst till det första elementet i vektorn.
`cend`	Returnerar en beständig iterator med slumpmässig åtkomst som pekar precis utanför vektorns ände.
`crbegin`	Returnerar en const iterator till det första elementet i en omvänd vektor.
`crend`	Returnerar en const-iterator till slutet av en omvänd vektor.
`clear`	Raderar elementen i vektorn.
`data`	Returnerar en pekare till det första elementet i vektorn.
`emplace`	Infogar ett element som är konstruerat på plats i vektorn vid en angiven position.
`emplace_back`	Lägger till ett element som är konstruerat på plats i slutet av vektorn.
`empty`	Testar om vektorcontainern är tom.
`end`	Returnerar en iterator med slumpmässig åtkomst som pekar mot slutet av vektorn.
`erase`	Tar bort ett element eller ett område med element i en vektor från angivna positioner.
`front`	Returnerar en referens till det första elementet i en vektor.
`get_allocator`	Returnerar ett objekt till den `allocator`-klass som används av en vektor.
`insert`	Infogar ett element eller många element i vektorn vid en angiven position.
`max_size`	Returnerar vektorns maximala längd.
`pop_back`	Tar bort elementet i slutet av vektorn.
`push_back`	Lägg till ett element i slutet av vektorn.
`rbegin`	Returnerar en iterator till det första elementet i en omvänd vektor.
`rend`	Returnerar en iterator till slutet av en omvänd vektor.
`reserve`	Reserverar en minsta lagringslängd för ett vektorobjekt.
`resize`	Anger en ny storlek för en vektor.
`shrink_to_fit`	Tar bort överkapacitet.
`size`	Returnerar antalet element i vektorn.
`swap`	Utbyter elementen i två vektorer.

Operatörer

Namn	Beskrivning
`operator[]`	Returnerar en referens till vektorelementet vid en angiven position.
`operator=`	Ersätter elementen i vektorn med en kopia av en annan vektor.

`allocator_type`

En typ som representerar allokeringsklassen för vektorobjektet.

typedef Allocator allocator_type;

Anmärkningar

allocator_type är synonymt med mallparametern Allocator.

Exempel

Se exemplet för get_allocator för ett exempel som använder allocator_type.

`assign`

Raderar en vektor och kopierar de angivna elementen till den tomma vektorn.

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

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

Parametrar

first
Positionen för det första elementet i området med element som ska kopieras.

last
Positionen för det första elementet utanför det område med element som ska kopieras.

count
Antalet kopior av ett element som infogas i vektorn.

value
Värdet för elementet som infogas i vektorn.

init_list
Den initializer_list som innehåller elementen som ska infogas.

Anmärkningar

Först raderar assign alla befintliga element i en vektor. Sedan infogar assign antingen ett angivet område med element från den ursprungliga vektorn i en vektor, eller så infogas kopior av ett nytt angivet värdeelement i en vektor.

Exempel

// 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 });
    cout << "v3 = ";
    for (auto& v : v3)
    {
        cout << v << " ";
    }
    cout << endl;
}

v1 = 10 20 30 40 50
v2 = 10 20 30 40 50
v3 = 4 4 4 4 4 4 4
v3 = 5 6 7

`at`

Returnerar en referens till elementet på en angiven plats i vektorn.

reference at(size_type position);

const_reference at(size_type position) const;

Parametrar

position
Det nedsänkta eller positionsnummer för elementet som ska refereras till i vektorn.

Returvärde

En referens till elementet som är nedsänkt i argumentet. Om position är större än vektorns storlek utlöser at ett undantag.

Anmärkningar

Om returvärdet för at tilldelas till en const_referencekan vektorobjektet inte ändras. Om returvärdet för at tilldelas till en referencekan vektorobjektet ändras.

Exempel

// 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`

Returnerar en referens till det sista elementet i vektorn.

reference back();

const_reference back() const;

Returvärde

Det sista elementet i vektorn. Om vektorn är tom är returvärdet odefinierat.

Anmärkningar

Om returvärdet för back tilldelas till en const_referencekan vektorobjektet inte ändras. Om returvärdet för back tilldelas till en referencekan vektorobjektet ändras.

När du kompileras med hjälp av _ITERATOR_DEBUG_LEVEL definierat som 1 eller 2 uppstår ett körningsfel om du försöker komma åt ett element i en tom vektor. Mer information finns i Kontrollerade iteratorer.

Exempel

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

The last integer of v1 is 11
The next-to-last integer of v1 is 10

`begin`

Returnerar en iterator med slumpmässig åtkomst till det första elementet i vektorn.

const_iterator begin() const;

iterator begin();

Returvärde

En iterator med slumpmässig åtkomst som adresserar det första elementet i vector eller till platsen som lyckas med en tom vector. Jämför alltid värdet som returneras med vector::end för att säkerställa att det är giltigt.

Anmärkningar

Om returvärdet för begin har tilldelats till en vector::const_iteratorkan vector-objektet inte ändras. Om returvärdet för begin har tilldelats till en vector::iteratorkan vector-objektet ändras.

Exempel

// 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`

Returnerar antalet element som vektorn kan innehålla utan att allokera mer lagringsutrymme.

size_type capacity() const;

Returvärde

Den aktuella lagringslängden som allokerats för vektorn.

Anmärkningar

Medlemsfunktionen resize blir effektivare om tillräckligt med minne allokeras för att rymma den. Använd medlemsfunktionen reserve för att ange mängden allokerat minne.

Exempel

// 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`

Returnerar en const iterator som adresserar det första elementet i intervallet.

const_iterator cbegin() const;

Returvärde

En const iterator för slumpmässig åtkomst som pekar på det första elementet i intervallet eller platsen precis utanför slutet av ett tomt intervall (för ett tomt intervall cbegin() == cend()).

Anmärkningar

Med returvärdet för cbeginkan elementen i intervallet inte ändras.

Du kan använda den här medlemsfunktionen i stället för funktionen begin() medlem för att garantera att returvärdet är const_iterator. Vanligtvis används det i med nyckelordet auto typavdrag, som du ser i följande exempel. I exemplet bör du överväga att Container vara en ändringsbar (icke-const) container av något slag som stöder begin() och cbegin().

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

auto i2 = Container.cbegin();
// i2 is Container<T>::const_iterator

`cend`

Returnerar en const iterator som pekar på elementet som följer det sista elementet i vektorn.

const_iterator cend() const;

Returvärde

En const tidigare iterator för vektorn. Den pekar på elementet som följer det sista elementet i vektorn. Det elementet är en platshållare och bör inte avrefereras. Använd den endast för jämförelser. Om vektorn är tom vector::cend() == vector::cbegin().

Anmärkningar

cend används för att testa om en iterator har passerat slutet av sitt intervall.

Du kan använda den här medlemsfunktionen i stället för funktionen end() medlem för att garantera att returvärdet är const_iterator. Vanligtvis används det med nyckelordet auto typavdrag, som du ser i följande exempel. I exemplet bör du överväga att Container vara en ändringsbar (icke-const) container av något slag som stöder end() och cend().

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

auto i2 = Container.cend();
// i2 is Container<T>::const_iterator

Värdet som returneras av cend ska inte derefereras. Använd den endast för jämförelser.

`clear`

Raderar elementen i vektorn.

void clear();

Exempel

// 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`

En typ som ger en iterator med slumpmässig åtkomst som kan läsa ett const element i en vektor.

typedef implementation-defined const_iterator;

Anmärkningar

En typ const_iterator kan inte användas för att ändra värdet för ett element.

Exempel

Se exemplet för tillbaka för ett exempel som använder const_iterator.

`const_pointer`

En typ som ger en pekare till ett const element i en vektor.

typedef typename Allocator::const_pointer const_pointer;

Anmärkningar

En typ const_pointer kan inte användas för att ändra värdet för ett element.

En iterator används oftare för att komma åt ett vektorelement.

`const_reference`

En typ som ger en referens till ett const element som lagras i en vektor. Den används för att läsa och utföra const åtgärder.

typedef typename Allocator::const_reference const_reference;

Anmärkningar

En typ const_reference kan inte användas för att ändra värdet för ett element.

Exempel

// 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`

En typ som ger en iterator med slumpmässig åtkomst som kan läsa alla const element i vektorn.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Anmärkningar

En typ const_reverse_iterator inte kan ändra värdet för ett element och används för att iterera genom vektorn i omvänd ordning.

Exempel

Se rbegin för ett exempel på hur du deklarerar och använder en iterator.

`crbegin`

Returnerar en const iterator till det första elementet i en omvänd vektor.

const_reverse_iterator crbegin() const;

Returvärde

En const reverse random-access iterator som hanterar det första elementet i en omvänd vector eller som tar upp vad som hade varit det sista elementet i den oreverserade vector.

Anmärkningar

Med returvärdet för crbeginkan vector-objektet inte ändras.

Exempel

// 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`

Returnerar en const omvänd iterator som pekar på elementet efter det sista elementet i den omvända vektorn.

const_reverse_iterator crend() const;

Returvärde

En const omvänd iterator för den omvända vektorn. Den pekar på elementet som följer det sista elementet i den omvända vektorn, som är samma som elementet före det första elementet i den icke-omvända vektorn. Det elementet är en platshållare och bör inte avrefereras. Använd den endast för jämförelser.

Anmärkningar

crend används med omvända vector precis som vector::cend används med en vector.

Med returvärdet för crend (lämpligt minskas) kan vector-objektet inte ändras.

crend kan användas för att testa om en omvänd iterator har nått slutet av sin vector.

Värdet som returneras av crend ska inte derefereras. Använd den endast för jämförelser.

Exempel

// 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`

Returnerar en pekare till det första elementet i vektorn.

const_pointer data() const;

pointer data();

Returvärde

En pekare till det första elementet i vector eller till platsen som lyckas med en tom vector.

Exempel

// 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`

En typ som ger skillnaden mellan två iteratorer som refererar till element inom samma vektor.

typedef typename Allocator::difference_type difference_type;

Anmärkningar

En difference_type kan också beskrivas som antalet element mellan två pekare, eftersom en pekare till ett element innehåller dess adress.

En iterator används oftare för att komma åt ett vektorelement.

Exempel

// 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`

Infogar ett element som är konstruerat på plats i vektorn vid en angiven position.

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

Parametrar

position
Positionen i vector där det första elementet infogas.

args
Konstruktorargument. Funktionen härleder vilken konstruktoröverlagring som ska anropas baserat på de angivna argumenten.

Returvärde

Funktionen returnerar en iterator som pekar på positionen där det nya elementet infogades i vector.

Anmärkningar

Alla infogningsåtgärder kan vara dyra, se vector klass för en diskussion om vector prestanda.

Exempel

// 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`

Lägger till ett element som är konstruerat på plats i slutet av vektorn.

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

Parametrar

args
Konstruktorargument. Funktionen härleder vilken konstruktoröverlagring som ska anropas baserat på de angivna argumenten.

Exempel

#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`

Testar om vektorn är tom.

bool empty() const;

Returvärde

true om vektorn är tom; false om vektorn inte är tom.

Exempel

// 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`

Returnerar en tidigare iterator som pekar på elementet som följer det sista elementet i vektorn.

iterator end();

const_iterator end() const;

Returvärde

En tidigare iterator för vektorn. Den pekar på elementet som följer det sista elementet i vektorn. Det elementet är en platshållare och bör inte avrefereras. Använd den endast för jämförelser. Om vektorn är tom vector::end() == vector::begin().

Anmärkningar

Om returvärdet för end tilldelas till en variabel av typen const_iteratorkan vektorobjektet inte ändras. Om returvärdet för end tilldelas till en variabel av typen iteratorkan vektorobjektet ändras.

Exempel

// 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`

Tar bort ett element eller ett område med element i en vektor från angivna positioner.

iterator erase(
    const_iterator position);

iterator erase(
    const_iterator first,
    const_iterator last);

Parametrar

position
Positionen för elementet som ska tas bort från vektorn.

first
Positionen för det första elementet som tagits bort från vektorn.

last
Placera precis utanför det sista elementet som tagits bort från vektorn.

Returvärde

En iterator som anger det första elementet som återstår utöver alla element som tas bort, eller en pekare till slutet av vektorn om det inte finns något sådant element.

Exempel

// 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`

Returnerar en referens till det första elementet i en vektor.

reference front();

const_reference front() const;

Returvärde

En referens till det första elementet i vektorobjektet. Om vektorn är tom är returen odefinierad.

Anmärkningar

Om returvärdet för front tilldelas till en const_referencekan vektorobjektet inte ändras. Om returvärdet för front tilldelas till en referencekan vektorobjektet ändras.

Exempel

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

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

The first integer of v1 is 10
Now, the first integer of v1 is 11

`get_allocator`

Returnerar en kopia av allokeringsobjektet som används för att konstruera vektorn.

Allocator get_allocator() const;

Returvärde

Allokeraren som används av vektorn.

Anmärkningar

Allokerare för vektorklassen anger hur klassen hanterar lagring. Standardallokeringsprogrammen som levereras med C++ Standard Library-containerklasser räcker för de flesta programmeringsbehov. Att skriva och använda din egen allokeringsklass är en avancerad C++-funktion.

Exempel

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

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`

Infogar ett element, eller många element eller ett område med element i vektorn vid en angiven position.

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

Parametrar

position
Positionen i vektorn där det första elementet infogas.

value
Värdet för elementet som infogas i vektorn.

count
Antalet element som infogas i vektorn.

first
Positionen för det första elementet i området med element som ska kopieras.

last
Positionen för det första elementet utöver det område av element som ska kopieras.

Returvärde

De två första insert-funktionerna returnerar en iterator som pekar på positionen där det nya elementet infogades i vektorn.

Anmärkningar

Som en förutsättning får first och last inte vara iteratorer i vektorn, eller så är beteendet odefinierat. Alla infogningsåtgärder kan vara dyra, se vector klass för en diskussion om vector prestanda.

Exempel

// 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`

En typ som ger en iterator med slumpmässig åtkomst som kan läsa eller ändra alla element i en vektor.

typedef implementation-defined iterator;

Anmärkningar

En typ iterator kan användas för att ändra värdet för ett element.

Exempel

Se exemplet för begin.

`max_size`

Returnerar vektorns maximala längd.

size_type max_size() const;

Returvärde

Den maximala möjliga längden på vektorn.

Exempel

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

The maximum possible length of the vector is 4611686018427387903.

`operator[]`

Returnerar en referens till vektorelementet vid en angiven position.

reference operator[](size_type position);

const_reference operator[](size_type position) const;

Parametrar

position
Vektorelementets position.

Returvärde

Om den angivna positionen är större än eller lika med containerns storlek är resultatet odefinierat.

Anmärkningar

Om returvärdet för operator[] tilldelas till en const_referencekan vektorobjektet inte ändras. Om returvärdet för operator[] tilldelas till en referens kan vektorobjektet ändras.

När du kompileras med hjälp av _ITERATOR_DEBUG_LEVEL definierat som 1 eller 2 uppstår ett körningsfel om du försöker komma åt ett element utanför vektorns gränser. Mer information finns i Kontrollerade iteratorer.

Exempel

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

The second integer of v1 is 20

`operator=`

Ersätter elementen i vektorn med en kopia av en annan vektor.

vector& operator=(const vector& right);

vector& operator=(vector&& right);

Parametrar

right
Den vector som kopieras till vector.

Anmärkningar

När du har raderat befintliga element i en vectoroperator= antingen kopierar eller flyttar innehållet i right till vector.

Exempel

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

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

`pointer`

En typ som ger en pekare till ett element i en vektor.

typedef typename Allocator::pointer pointer;

Anmärkningar

En typ pointer kan användas för att ändra värdet för ett element.

Exempel

// 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`

Tar bort elementet i slutet av vektorn.

void pop_back();

Anmärkningar

Ett kodexempel finns i vector::p ush_back().

`push_back`

Lägger till ett element i slutet av vektorn.

void push_back(const T& value);

void push_back(T&& value);

Parametrar

value
Värdet som ska tilldelas till elementet som läggs till i slutet av vektorn.

Exempel

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

vector data:
  10 elements: (10) (11) (12) (13) (14) (15) (16) (17) (18) (19)
v.back(): (19)
v.back(): (18)
v.back(): (17)
v.back(): (16)
v.back(): (15)
v.back(): (14)
v.back(): (13)
v.back(): (12)
v.back(): (11)
v.back(): (10)

`rbegin`

Returnerar en iterator till det första elementet i en omvänd vektor.

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

Returvärde

En omvänd iterator för slumpmässig åtkomst som adresserar det första elementet i en omvänd vektor eller som behandlar vad som var det sista elementet i den oreverserade vektorn.

Anmärkningar

Om returvärdet för rbegin tilldelas till en const_reverse_iteratorkan vektorobjektet inte ändras. Om returvärdet för rbegin tilldelas till en reverse_iteratorkan vektorobjektet ändras.

Exempel

// 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`

En typ som ger en referens till ett element som lagras i en vektor.

typedef typename Allocator::reference reference;

Exempel

Se at för ett exempel på hur du använder reference i vektorklassen.

`rend`

Returnerar en omvänd iterator som pekar på elementet efter det sista elementet i den omvända vektorn.

const_reverse_iterator rend() const;
reverse_iterator rend();

Returvärde

En omvänd iterator för den omvända vektorn. Den pekar på elementet som följer det sista elementet i den omvända vektorn, som är samma som elementet före det första elementet i den icke-omvända vektorn. Det elementet är en platshållare och bör inte avrefereras. Använd den endast för jämförelser.

Anmärkningar

rend används med en omvänd vektor precis som end används med en vektor.

Om returvärdet för rend tilldelas till en const_reverse_iteratorkan vektorobjektet inte ändras. Om returvärdet för rend tilldelas till en reverse_iteratorkan vektorobjektet ändras.

rend kan användas för att testa om en omvänd iterator har nått slutet av sin vektor.

Värdet som returneras av rend ska inte derefereras. Använd den endast för jämförelser.

Exempel

// 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`

Reserverar en minsta lagringslängd för ett vektorobjekt och allokerar utrymme om det behövs.

void reserve(size_type count);

Parametrar

count
Den minsta lagringslängd som ska allokeras för vektorn.

Exempel

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

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

    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`

Anger en ny storlek för en vektor.

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

Parametrar

new_size
Den nya storleken på vektorn.

value
Initieringsvärdet för nya element har lagts till i vektorn om den nya storleken är större än den ursprungliga storleken. Om värdet utelämnas använder de nya objekten sin standardkonstruktor.

Anmärkningar

Om containerns storlek är mindre än den begärda storleken new_sizeresize lägger till element i vektorn tills den når den begärda storleken. När containerns storlek är större än den begärda storleken tar resize bort elementen närmast slutet av containern tills den når storleken new_size. Ingen åtgärd vidtas om containerns nuvarande storlek är samma som den begärda storleken.

size återspeglar vektorns aktuella storlek.

Exempel

// 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 << "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);
}

After declaring an empty vector:
   the vector's size is: 0
   the vector's capacity is: 0
   the vector's maximum size is: 4611686018427387903
   the vector's contents:

After adding an element:
   the vector's size is: 1
   the vector's capacity is: 1
   the vector's maximum size is: 4611686018427387903
   the vector's contents: -1

After adding 10 elements:
   the vector's size is: 10
   the vector's capacity is: 13
   the vector's maximum size is: 4611686018427387903
   the vector's contents: -1 1 2 3 4 5 6 7 8 9

After resizing to 6 elements without an initialization value:
   the vector's size is: 6
   the vector's capacity is: 13
   the vector's maximum size is: 4611686018427387903
   the vector's contents: -1 1 2 3 4 5

After resizing to 9 elements with an initialization value of 999:
   the vector's size is: 9
   the vector's capacity is: 13
   the vector's maximum size is: 4611686018427387903
   the vector's contents: -1 1 2 3 4 5 999 999 999

After resizing to 12 elements without an initialization value:
   the vector's size is: 12
   the vector's capacity is: 13
   the vector's maximum size is: 4611686018427387903
   the vector's contents: -1 1 2 3 4 5 999 999 999 0 0 0

After vector::reserve(1000):
   the vector's size is: 12
   the vector's capacity is: 1000
   the vector's maximum size is: 4611686018427387903

After vector::resize(2000):
   the vector's size is: 2000
   the vector's capacity is: 2000
   the vector's maximum size is: 4611686018427387903

`reverse_iterator`

En typ som ger en iterator med slumpmässig åtkomst som kan läsa eller ändra alla element i en omvänd vektor.

typedef std::reverse_iterator<iterator> reverse_iterator;

Anmärkningar

En typ reverse_iterator används för att iterera genom vektorn i omvänd ordning.

Exempel

Se exemplet för rbegin.

`shrink_to_fit`

Tar bort överkapacitet.

void shrink_to_fit();

Exempel

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

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

    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`

Returnerar antalet element i vektorn.

size_type size() const;

Returvärde

Vektorns aktuella längd.

Exempel

// 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`

En typ som räknar antalet element i en vektor.

typedef typename Allocator::size_type size_type;

Exempel

Se exemplet för capacity.

`swap`

Utbyter elementen i två vektorer.

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

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

Parametrar

right
En vektor som tillhandahåller de element som ska växlas. Eller en vektor vars element ska bytas ut med elementen i vektorn left.

left
En vektor vars element ska bytas ut mot elementen i vektorn right.

Exempel

// 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`

En typ som representerar datatypen som lagras i en vektor.

typedef typename Allocator::value_type value_type;

Anmärkningar

value_type är synonymt med mallparametern Type.

Exempel

// 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`

Konstruerar en vektor. Överlagringar konstruerar en vektor med en viss storlek eller med element av ett visst värde. Eller som en kopia av hela eller delar av någon annan vektor. Vissa överlagringar gör också att du kan ange allokeraren som ska användas.

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

Parametrar

allocator
Allokeringsklassen som ska användas med det här objektet. get_allocator returnerar allokeringsklassen för objektet.

count
Antalet element i den konstruerade vektorn.

value
Värdet för elementen i den konstruerade vektorn.

source
Den vektor som den konstruerade vektorn ska vara en kopia av.

first
Positionen för det första elementet i området med element som ska kopieras.

last
Positionen för det första elementet utanför det område med element som ska kopieras.

init_list
Den initializer_list som innehåller de element som ska kopieras.

Anmärkningar

Alla konstruktorer lagrar ett allokeringsobjekt (allocator) och initierar vektorn.

De två första konstruktorerna anger en tom inledande vektor. Den andra konstruktorn anger uttryckligen vilken allokeringstyp (allocator) som ska användas.

Den tredje konstruktorn anger en upprepning av ett angivet tal (count) av element i standardvärdet för klassen Type.

Den fjärde och femte konstruktorn anger en upprepning av (count) element av värdet value.

Den sjätte konstruktorn anger en kopia av vektorn source.

Den sjunde konstruktorn flyttar vektorn source.

Den åttonde konstruktorn använder en initializer_list för att ange elementen.

De nionde och tionde konstruktorerna kopierar intervallet [first, last) för en vektor.

Exempel

// 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

Se även

Trådsäkerhet i C++ Standard Library
C++ standardbiblioteksreferens

Dela via

vector klass

Syntax

Parametrar

Anmärkningar

Medlemmar

Konstruktörer

Typedefs

Funktioner

Operatörer

allocator_type

Anmärkningar

Exempel

assign

Parametrar

Anmärkningar

Exempel

at

Parametrar

Returvärde

Anmärkningar

Exempel

back

Returvärde

Anmärkningar

Exempel

begin

Returvärde

Anmärkningar

Exempel

capacity

Returvärde

Anmärkningar

Exempel

cbegin

Returvärde

Anmärkningar

cend

Returvärde

Anmärkningar

clear

Exempel

const_iterator

Anmärkningar

Exempel

const_pointer

Anmärkningar

const_reference

Anmärkningar

Exempel

const_reverse_iterator

Anmärkningar

Exempel

crbegin

Returvärde

Anmärkningar

Exempel

crend

Returvärde

Anmärkningar

Exempel

data

Returvärde

Exempel

difference_type

Anmärkningar

Exempel

emplace

Parametrar

Returvärde

Anmärkningar

Exempel

emplace_back

Parametrar

Exempel

empty

Returvärde

Exempel

end

Returvärde

`vector` klass

`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`