Třída vector
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
Název | 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
Název | 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
Název | 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
Název | 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_reference
vektoru, nelze upravit. Pokud je vrácená hodnota at
přiřazena k objektu reference
vektoru, 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_reference
vektoru, nelze upravit. Pokud je vrácená hodnota back
přiřazena k objektu reference
vektoru, 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é cbegin
hodnotě 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 crbegin
vector
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_reference
vektoru, nelze upravit. Pokud je vrácená hodnota front
přiřazena k objektu reference
vektoru, 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_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_reference
vektoru, 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_iterator
vektoru, nelze upravit. Pokud je vrácená hodnota rbegin
přiřazena k objektu reverse_iterator
vektoru, 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_size
resize
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;
}
44
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