Třída `vector`

Článek
09/02/2023

Třída vektoru standardní knihovny C++ je šablona třídy pro kontejnery sekvence. Vektor ukládá prvky daného typu v lineárním uspořádání a umožňuje rychlý náhodný přístup k libovolnému prvku. Vektor je upřednostňovaným kontejnerem pro sekvenci, pokud je výkon náhodného přístupu na úrovni Premium.

Syntaxe

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

Parametry

Type
Datový typ elementu, který má být uložen v vektoru

Allocator
Typ, který představuje uložený objekt alokátoru, který zapouzdřuje podrobnosti o přidělení a uvolnění paměti vektoru. Tento argument je nepovinný a výchozí hodnota je allocator<Type>.

Poznámky

Vektory umožňují konstantní vkládání a odstraňování času na konci sekvence. Vložení nebo odstranění prvků uprostřed vektoru vyžaduje lineární čas. Kontejner deque třídy je rychlejší při vkládání a odstraňování na začátku a na konci sekvence. Kontejner list třídy je rychlejší při vkládání a odstraňování v libovolném umístění v rámci sekvence.

Vektorová relokace nastane, když členová funkce musí zvýšit sekvenci obsaženou ve vektorovém objektu nad rámec aktuální kapacity úložiště. Jiné vkládání a mazání můžou v sekvenci měnit různé adresy úložiště. Ve všech takových případech se iterátory nebo odkazy, které odkazují na změněné části sekvence, stanou neplatnými. Pokud nedojde k žádné relokaci, zůstanou platné pouze iterátory a odkazy před vložením nebo bodem odstranění.

Třída vector<bool> je úplná specializace vektoru šablony třídy pro prvky typu bool. Má alokátor základního typu používaného specializacem.

Referenční vector<bool> třída je vnořená třída , jejíž objekty mohou poskytovat odkazy na prvky (jednotlivé bity) v rámci objektu vector<bool> .

Členové

Konstruktory

Jméno	popis
`vector`	Vytvoří vektor určité velikosti nebo s prvky určité hodnoty nebo s určitým `allocator` nebo jako kopií jiného vektoru.

Typedefs

Jméno	popis
`[allocator_type]`(#allocator_type)	Typ, který představuje `allocator` třídu vektorového objektu.
`const_iterator`	Typ, který poskytuje iterátor náhodného přístupu, který může číst `const` prvek v vektoru.
`const_pointer`	Typ, který poskytuje ukazatel na `const` prvek vektoru.
`const_reference`	Typ, který poskytuje odkaz na `const` prvek uložený ve vektoru. Používá se ke čtení a provádění `const` operací.
`const_reverse_iterator`	Typ, který poskytuje iterátor náhodného přístupu, který může číst libovolný `const` prvek vektoru.
`difference_type`	Typ, který poskytuje rozdíl mezi adresami dvou prvků vektoru.
`iterator`	Typ, který poskytuje iterátor náhodného přístupu, který může číst nebo upravovat libovolný prvek vektoru.
`pointer`	Typ, který poskytuje ukazatel na prvek vektoru.
`reference`	Typ, který poskytuje odkaz na prvek uložený ve vektoru.
`reverse_iterator`	Typ, který poskytuje iterátor náhodného přístupu, který může číst nebo upravovat libovolný prvek v obráceném vektoru.
`size_type`	Typ, který spočítá počet prvků ve vektoru.
`value_type`	Typ, který představuje datový typ uložený ve vektoru.

Funkce

Jméno	popis
`assign`	Vymaže vektor a zkopíruje zadané prvky do prázdného vektoru.
`at`	Vrátí odkaz na prvek v zadaném umístění vektoru.
`back`	Vrátí odkaz na poslední prvek vektoru.
`begin`	Vrátí iterátor náhodného přístupu k prvnímu prvku vektoru.
`capacity`	Vrátí počet prvků, které by vektor mohl obsahovat bez přidělení většího úložiště.
`cbegin`	Vrátí iterátor const náhodného přístupu k prvnímu prvku vektoru.
`cend`	Vrátí iterátor const s náhodným přístupem, který odkazuje těsně za koncem vektoru.
`crbegin`	Vrátí konstantní iterátor na první prvek v obráceném vektoru.
`crend`	Vrátí konstantní iterátor na konec obráceného vektoru.
`clear`	Vymaže prvky vektoru.
`data`	Vrátí ukazatel na první prvek vektoru.
`emplace`	Vloží prvek vytvořený na místě do vektoru na určené pozici.
`emplace_back`	Přidá prvek vytvořený na místě na konec vektoru.
`empty`	Testuje, jestli je kontejner vektorů prázdný.
`end`	Vrátí iterátor s náhodným přístupem, který odkazuje na konec vektoru.
`erase`	Odebere prvek nebo oblast prvků ve vektoru ze zadaných pozic.
`front`	Vrátí odkaz na první prvek vektoru.
`get_allocator`	Vrátí objekt do `allocator` třídy používané vektorem.
`insert`	Vloží prvek nebo mnoho prvků do vektoru na zadanou pozici.
`max_size`	Vrátí maximální délku vektoru.
`pop_back`	Odstraní prvek na konci vektoru.
`push_back`	Přidejte prvek na konec vektoru.
`rbegin`	Vrátí iterátor na první prvek v obráceném vektoru.
`rend`	Vrátí iterátor na konec obráceného vektoru.
`reserve`	Zarezervuje minimální délku úložiště pro vektorový objekt.
`resize`	Určuje novou velikost vektoru.
`shrink_to_fit`	Zahodí nadbytečnou kapacitu.
`size`	Vrátí počet prvků vektoru.
`swap`	Vymění prvky dvou vektorů.

Operátory

Jméno	popis
`operator[]`	Vrátí odkaz na prvek vektoru na určené pozici.
`operator=`	Nahradí prvky vektoru kopií jiného vektoru.

`allocator_type`

Typ, který představuje třídu alokátoru pro vektorový objekt.

typedef Allocator allocator_type;

Poznámky

allocator_type je synonymem parametru Allocatoršablony .

Příklad

Podívejte se na příklad get_allocator , který používá allocator_type.

`assign`

Vymaže vektor a zkopíruje zadané prvky do prázdného vektoru.

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

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

Parametry

first
Pozice prvního prvku v rozsahu prvků, které se mají zkopírovat.

last
Pozice prvního prvku nad rozsah prvků, které se mají zkopírovat.

count
Počet kopií prvku, který se vkládá do vektoru.

value
Hodnota prvku, který se vkládá do vektoru.

init_list
Initializer_list obsahující prvky, které chcete vložit.

Poznámky

assign Nejprve vymaže všechny existující prvky ve vektoru. assign Pak buď vloží zadaný rozsah prvků z původního vektoru do vektoru, nebo vloží kopie nového zadaného prvku hodnoty do vektoru.

Příklad

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

Vrátí odkaz na prvek v zadaném umístění vektoru.

reference at(size_type position);

const_reference at(size_type position) const;

Parametry

position
Dolní index nebo číslo pozice prvku, který má odkazovat ve vektoru.

Vrácená hodnota

Odkaz na prvek, který je v argumentu dolní index. Pokud position je větší než velikost vektoru, at vyvolá výjimku.

Poznámky

Pokud je vrácená hodnota at přiřazena k objektu const_referencevektoru, nelze upravit. Pokud je vrácená hodnota at přiřazena k objektu referencevektoru, lze upravit.

Příklad

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

Vrátí odkaz na poslední prvek vektoru.

reference back();

const_reference back() const;

Vrácená hodnota

Poslední prvek vektoru. Pokud je vektor prázdný, návratová hodnota není definována.

Poznámky

Pokud je vrácená hodnota back přiřazena k objektu const_referencevektoru, nelze upravit. Pokud je vrácená hodnota back přiřazena k objektu referencevektoru, lze upravit.

Při kompilaci pomocí _ITERATOR_DEBUG_LEVEL definovaného jako 1 nebo 2 dojde k chybě za běhu, pokud se pokusíte získat přístup k prvku v prázdném vektoru. Další informace naleznete v tématu Kontrola iterátorů.

Příklad

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

Vrátí iterátor náhodného přístupu k prvnímu prvku vektoru.

const_iterator begin() const;

iterator begin();

Vrácená hodnota

Iterátor náhodného přístupu adresující první prvek v vector umístění nebo umístění, které je úspěšné prázdné vector. Vždy porovnejte vrácenou hodnotu vector::end , abyste měli jistotu, že je platná.

Poznámky

Pokud je vrácená hodnota begin přiřazena k objektu vector::const_iterator, vector nelze objekt změnit. Pokud je vrácená hodnota begin přiřazena k objektu vector::iterator, vector lze objekt upravit.

Příklad

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

Vrátí počet prvků, které by vektor mohl obsahovat bez přidělení většího úložiště.

size_type capacity() const;

Vrácená hodnota

Aktuální délka úložiště přidělená vektoru.

Poznámky

Členová funkce resize bude efektivnější, pokud je k dispozici dostatek paměti. Pomocí členské funkce reserve určete množství přidělené paměti.

Příklad

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

const Vrátí iterátor, který řeší první prvek v oblasti.

const_iterator cbegin() const;

Vrácená hodnota

const Iterátor náhodného přístupu, který odkazuje na první prvek oblasti nebo umístění těsně za koncem prázdné oblasti (pro prázdnou oblast, cbegin() == cend()).

Poznámky

Při návratové cbeginhodnotě nelze upravit prvky v oblasti.

Tuto členská funkce můžete použít místo begin() členské funkce, abyste zajistili, že návratová hodnota je const_iterator. Obvykle se používá s klíčovým slovem odpočtu auto typu, jak je znázorněno v následujícím příkladu. V příkladu zvažte Container , že je upravitelný (non- const) kontejner jakéhokoli druhu, který podporuje begin() a cbegin().

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

// i2 is Container<T>::const_iterator

`cend`

const Vrátí poslední iterátor konce, který odkazuje na prvek za posledním prvkem vektoru.

const_iterator cend() const;

Vrácená hodnota

Poslední const iterátor vektoru. Odkazuje na prvek za posledním prvkem vektoru. Tento prvek je zástupný symbol a neměl by být dereferenced. Používejte ho jenom pro porovnání. Pokud je vektor prázdný, pak vector::cend() == vector::cbegin().

Poznámky

cend slouží k otestování, zda iterátor předal konec jeho rozsahu.

Tuto členská funkce můžete použít místo end() členské funkce, abyste zajistili, že návratová hodnota je const_iterator. Obvykle se používá s klíčovým slovem odpočtu auto typu, jak je znázorněno v následujícím příkladu. V příkladu zvažte Container , že je upravitelný (non- const) kontejner jakéhokoli druhu, který podporuje end() a cend().

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

// i2 is Container<T>::const_iterator

Hodnota vrácená cend by neměla být dereferenced. Používejte ho jenom pro porovnání.

`clear`

Vymaže prvky vektoru.

void clear();

Příklad

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

Typ, který poskytuje iterátor náhodného přístupu, který může číst const prvek v vektoru.

typedef implementation-defined const_iterator;

Poznámky

Typ const_iterator nelze použít k úpravě hodnoty elementu.

Příklad

Příklad najdete v příkladu, který používá const_iterator.

`const_pointer`

Typ, který poskytuje ukazatel na const prvek vektoru.

typedef typename Allocator::const_pointer const_pointer;

Poznámky

Typ const_pointer nelze použít k úpravě hodnoty elementu.

Iterátor se častěji používá pro přístup k elementu vektoru.

`const_reference`

Typ, který poskytuje odkaz na const prvek uložený ve vektoru. Používá se ke čtení a provádění const operací.

typedef typename Allocator::const_reference const_reference;

Poznámky

Typ const_reference nelze použít k úpravě hodnoty elementu.

Příklad

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

Typ, který poskytuje iterátor náhodného přístupu, který může číst libovolný const prvek vektoru.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Poznámky

Typ const_reverse_iterator nemůže změnit hodnotu prvku a používá se k iteraci vektoru obráceně.

Příklad

Podívejte rbegin se, jak deklarovat a používat iterátor.

`crbegin`

Vrátí konstantní iterátor na první prvek v obráceném vektoru.

const_reverse_iterator crbegin() const;

Vrácená hodnota

Const reverse random-access iterator adresuje první prvek v obráceném vector směru nebo adresování toho, co byl poslední prvek v nereverze .vector

Poznámky

S návratovou crbeginvector hodnotou objektu nelze změnit.

Příklad

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

const Vrátí zpětné iterátor konce konce, který odkazuje na prvek za posledním prvkem obráceného vektoru.

const_reverse_iterator crend() const;

Vrácená hodnota

Obrácený const iterátor pro obrácený vektor. Odkazuje na prvek za posledním prvkem obráceného vektoru, který je stejný jako prvek před prvním prvkem neopakovaného vektoru. Tento prvek je zástupný symbol a neměl by být dereferenced. Používejte ho jenom pro porovnání.

Poznámky

crend se používá s obráceným opakem vector , stejně jako vector::cend se používá s vector.

Při návratové crend hodnotě (vhodnou dekrementací) vector nelze objekt upravit.

crend lze použít k otestování, zda reverzní iterátor dosáhl konce jeho vector.

Hodnota vrácená crend by neměla být dereferenced. Používejte ho jenom pro porovnání.

Příklad

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

Vrátí ukazatel na první prvek vektoru.

const_pointer data() const;

pointer data();

Vrácená hodnota

Ukazatel na první prvek v vector nebo na umístění, které je úspěšné prázdné vector.

Příklad

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

Typ, který poskytuje rozdíl mezi dvěma iterátory, které odkazují na prvky ve stejném vektoru.

typedef typename Allocator::difference_type difference_type;

Poznámky

A difference_type lze také popsat jako počet prvků mezi dvěma ukazateli, protože ukazatel na prvek obsahuje jeho adresu.

Iterátor se častěji používá pro přístup k elementu vektoru.

Příklad

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

Vloží prvek vytvořený na místě do vektoru na určené pozici.

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

Parametry

position
Pozice v místě, kde vector je vložen první prvek.

args
Argumenty konstruktoru. Funkce odvodí, které přetížení konstruktoru vyvolat na základě zadaných argumentů.

Vrácená hodnota

Funkce vrátí iterátor, který odkazuje na pozici, kde byl nový prvek vložen do objektu vector.

Poznámky

Jakákoli operace vložení může být náročná, viz vector třída pro diskuzi o výkonu vector .

Příklad

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

Přidá prvek vytvořený na místě na konec vektoru.

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

Parametry

args
Argumenty konstruktoru. Funkce odvodí, které přetížení konstruktoru vyvolat na základě zadaných argumentů.

Příklad

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

Testuje, jestli je vektor prázdný.

bool empty() const;

Vrácená hodnota

true pokud je vektor prázdný; false pokud vektor není prázdný.

Příklad

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

Vrátí poslední iterátor konce, který odkazuje na prvek za posledním prvkem vektoru.

iterator end();

const_iterator end() const;

Vrácená hodnota

Poslední iterátor vektoru. Odkazuje na prvek za posledním prvkem vektoru. Tento prvek je zástupný symbol a neměl by být dereferenced. Používejte ho jenom pro porovnání. Pokud je vektor prázdný, pak vector::end() == vector::begin().

Poznámky

Pokud je návratová end hodnota přiřazena proměnné typu const_iterator, vektorový objekt nelze upravit. Pokud je návratová end hodnota přiřazena proměnné typu iterator, vektorový objekt lze upravit.

Příklad

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

Odebere prvek nebo oblast prvků ve vektoru ze zadaných pozic.

iterator erase(
    const_iterator position);

iterator erase(
    const_iterator first,
    const_iterator last);

Parametry

position
Pozice prvku, který má být odebrán z vektoru.

first
Pozice prvního prvku odebraného z vektoru

last
Umístěte přímo za poslední prvek odebraný z vektoru.

Vrácená hodnota

Iterátor, který určuje první prvek, který zůstává nad rámec všech odebraných prvků, nebo ukazatel na konec vektoru, pokud takový prvek neexistuje.

Příklad

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

Vrátí odkaz na první prvek vektoru.

reference front();

const_reference front() const;

Vrácená hodnota

Odkaz na první prvek vektorového objektu. Pokud je vektor prázdný, návrat není definován.

Poznámky

Pokud je vrácená hodnota front přiřazena k objektu const_referencevektoru, nelze upravit. Pokud je vrácená hodnota front přiřazena k objektu referencevektoru, lze upravit.

Příklad

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

Vrátí kopii objektu alokátoru použitého k vytvoření vektoru.

Allocator get_allocator() const;

Vrácená hodnota

Alokátor používaný vektorem.

Poznámky

Alokátory třídy vektoru určují, jak třída spravuje úložiště. Výchozí alokátory dodávané s třídami kontejneru standardní knihovny C++ jsou dostatečné pro většinu programovacích potřeb. Psaní a používání vlastní třídy alokátoru je pokročilá funkce jazyka C++.

Příklad

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

Vloží prvek nebo mnoho prvků nebo rozsah prvků do vektoru na zadané pozici.

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

Parametry

position
Pozice ve vektoru, kde je vložen první prvek.

value
Hodnota prvku, který se vkládá do vektoru.

count
Počet prvků, které jsou vloženy do vektoru.

first
Pozice prvního prvku v oblasti prvků, které se mají zkopírovat.

last
Pozice prvního prvku nad rozsah prvků, které se mají zkopírovat.

Vrácená hodnota

První dvě insert funkce vrátí iterátor, který odkazuje na pozici, kde byl nový prvek vložen do vektoru.

Poznámky

Jako předpoklad first nesmí last být iterátory vektoru nebo chování není definováno. Jakákoli operace vložení může být náročná, viz vector třída pro diskuzi o výkonu vector .

Příklad

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

Typ, který poskytuje iterátor náhodného přístupu, který může číst nebo upravovat libovolný prvek vektoru.

typedef implementation-defined iterator;

Poznámky

Typ iterator lze použít k úpravě hodnoty elementu.

Příklad

Podívejte se na příklad pro begin.

`max_size`

Vrátí maximální délku vektoru.

size_type max_size() const;

Vrácená hodnota

Maximální možná délka vektoru.

Příklad

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

Vrátí odkaz na prvek vektoru na určené pozici.

reference operator[](size_type position);

const_reference operator[](size_type position) const;

Parametry

position
Pozice prvku vektoru.

Vrácená hodnota

Pokud je zadaná pozice větší nebo rovna velikosti kontejneru, výsledek je nedefinován.

Poznámky

Pokud je vrácená hodnota operator[] přiřazena k objektu const_referencevektoru, nelze upravit. Pokud je vrácená hodnota operator[] přiřazena odkazu, lze vektorový objekt upravit.

Při kompilaci pomocí _ITERATOR_DEBUG_LEVEL definovaného jako 1 nebo 2 dojde k chybě za běhu, pokud se pokusíte získat přístup k prvku mimo hranice vektoru. Další informace naleznete v tématu Kontrola iterátorů.

Příklad

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

Nahradí prvky vektoru kopií jiného vektoru.

vector& operator=(const vector& right);

vector& operator=(vector&& right);

Parametry

right
Zkopírovaná vector do souboru vector.

Poznámky

Po vymazání všech existujících prvků v souboru vector, operator= buď zkopíruje nebo přesune obsah right do vector.

Příklad

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

Typ, který poskytuje ukazatel na prvek vektoru.

typedef typename Allocator::pointer pointer;

Poznámky

Typ pointer lze použít k úpravě hodnoty elementu.

Příklad

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

Odstraní prvek na konci vektoru.

void pop_back();

Poznámky

Příklad kódu najdete v tématu vector::p ush_back().

`push_back`

Přidá prvek na konec vektoru.

void push_back(const T& value);

void push_back(T&& value);

Parametry

value
Hodnota, která se přiřadí elementu přidanému na konec vektoru.

Příklad

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

Vrátí iterátor na první prvek v obráceném vektoru.

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

Vrácená hodnota

Reverzní iterátor náhodného přístupu adresovaný prvním prvkem v obráceném vektoru nebo adresování toho, co bylo posledním prvkem v nereverzním vektoru.

Poznámky

Pokud je vrácená hodnota rbegin přiřazena k objektu const_reverse_iteratorvektoru, nelze upravit. Pokud je vrácená hodnota rbegin přiřazena k objektu reverse_iteratorvektoru, lze upravit.

Příklad

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

Typ, který poskytuje odkaz na prvek uložený ve vektoru.

typedef typename Allocator::reference reference;

Příklad

Podívejte at se na příklad použití reference ve třídě vektoru.

`rend`

Vrátí zpětné iterátor konce konce, který odkazuje na prvek za posledním prvkem obráceného vektoru.

const_reverse_iterator rend() const;
reverse_iterator rend();

Vrácená hodnota

Obrácený iterátor pro obrácený vektor. Odkazuje na prvek za posledním prvkem obráceného vektoru, který je stejný jako prvek před prvním prvkem neopakovaného vektoru. Tento prvek je zástupný symbol a neměl by být dereferenced. Používejte ho jenom pro porovnání.

Poznámky

rend se používá s obráceným vektorem stejně jako end u vektoru.

Pokud je vrácená hodnota rend přiřazena k objektu const_reverse_iterator, nelze vektorový objekt upravit. Pokud je vrácená hodnota rend přiřazena k objektu reverse_iterator, lze vektorový objekt upravit.

rend lze použít k otestování, zda reverzní iterátor dosáhl konce vektoru.

Hodnota vrácená rend by neměla být dereferenced. Používejte ho jenom pro porovnání.

Příklad

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

V případě potřeby si rezervuje minimální délku úložiště pro vektorový objekt a v případě potřeby přidělí prostor.

void reserve(size_type count);

Parametry

count
Minimální délka úložiště, která má být přidělena vektoru.

Příklad

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

Určuje novou velikost vektoru.

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

Parametry

new_size
Nová velikost vektoru.

value
Inicializační hodnota nových prvků přidaných do vektoru, pokud je nová velikost větší než původní velikost. Pokud je hodnota vynechána, nové objekty používají jejich výchozí konstruktor.

Poznámky

Pokud je velikost kontejneru menší než požadovaná velikost, přidá do vektoru prvky, new_sizeresize dokud nedosáhne požadované velikosti. Pokud je velikost kontejneru větší než požadovaná velikost, odstraní prvky nejblíže ke konci kontejneru, resize dokud nedosáhne velikosti new_size. Pokud je aktuální velikost kontejneru stejná jako požadovaná velikost, není provedena žádná akce.

size odráží aktuální velikost vektoru.

Příklad

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

Typ, který poskytuje iterátor náhodného přístupu, který může číst nebo upravovat libovolný prvek v obráceném vektoru.

typedef std::reverse_iterator<iterator> reverse_iterator;

Poznámky

Typ reverse_iterator se používá k iteraci vektoru v obráceném směru.

Příklad

Podívejte se na příklad pro rbegin.

`shrink_to_fit`

Zahodí nadbytečnou kapacitu.

void shrink_to_fit();

Příklad

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

Vrátí počet prvků vektoru.

size_type size() const;

Vrácená hodnota

Aktuální délka vektoru.

Příklad

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

Typ, který spočítá počet prvků ve vektoru.

typedef typename Allocator::size_type size_type;

Příklad

Podívejte se na příklad pro capacity.

`swap`

Vymění prvky dvou vektorů.

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

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

Parametry

right
Vektor poskytující prvky, které mají být prohozeny. Nebo vektor, jehož prvky mají být vyměňovány s prvky v vektoru left.

left
Vektor, jehož prvky mají být vyměňovány s prvky vektoru right.

Příklad

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

Typ, který představuje datový typ uložený ve vektoru.

typedef typename Allocator::value_type value_type;

Poznámky

value_type je synonymem parametru Typešablony .

Příklad

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

Vytvoří vektor. Přetížení vytváří vektor určité velikosti nebo s prvky určité hodnoty. Nebo jako kopie celého nebo části jiného vektoru. Některé přetížení také umožňují určit alokátor, který se má použít.

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

Parametry

allocator
Třída alokátoru, která se má použít s tímto objektem. get_allocator vrátí třídu alokátoru objektu.

count
Počet prvků ve vytvořeném vektoru.

value
Hodnota prvků v sestaveném vektoru.

source
Vektor, jehož bude vytvořený vektor kopií.

first
Pozice prvního prvku v rozsahu prvků, které se mají zkopírovat.

last
Pozice prvního prvku nad rozsah prvků, které se mají zkopírovat.

init_list
Obsahuje initializer_list prvky, které chcete zkopírovat.

Poznámky

Všechny konstruktory ukládají objekt alokátoru (allocator) a inicializují vektor.

První dva konstruktory určují prázdný počáteční vektor. Druhý konstruktor explicitně určuje typ alokátoru (allocator), který se má použít.

Třetí konstruktor určuje opakování zadaného počtu (count) prvků výchozí hodnoty pro třídu Type.

Čtvrtý a pátý konstruktor určuje opakování (count) prvků hodnoty value.

Šestý konstruktor určuje kopii vektoru source.

Sedmý konstruktor přesune vektor source.

Osmý konstruktor používá k určení prvků objekt initializer_list.

Devátý a desátý konstruktor zkopíruje rozsah [first, last) vektoru.

Příklad

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

Viz také

Bezpečný přístup z více vláken ve standardní knihovně C++
Standardní knihovna C++ – referenční dokumentace

Třída vector

Syntaxe

Parametry

Poznámky

Členové

Konstruktory

Typedefs

Funkce

Operátory

allocator_type

Poznámky

Příklad

assign

Parametry

Poznámky

Příklad

at

Parametry

Vrácená hodnota

Poznámky

Příklad

back

Vrácená hodnota

Poznámky

Příklad

begin

Vrácená hodnota

Poznámky

Příklad

capacity

Vrácená hodnota

Poznámky

Příklad

cbegin

Vrácená hodnota

Poznámky

cend

Vrácená hodnota

Poznámky

clear

Příklad

const_iterator

Poznámky

Příklad

const_pointer

Poznámky

const_reference

Poznámky

Příklad

const_reverse_iterator

Poznámky

Příklad

crbegin

Vrácená hodnota

Poznámky

Příklad

crend

Vrácená hodnota

Poznámky

Příklad

data

Vrácená hodnota

Příklad

difference_type

Poznámky

Příklad

emplace

Parametry

Vrácená hodnota

Poznámky

Příklad

emplace_back

Parametry

Příklad

empty

Vrácená hodnota

Příklad

end

Vrácená hodnota

Poznámky

Třída `vector`

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

`swap`