vector osztály

A C++ standard kódtár vektorosztálya a sorozattárolók osztálysablonja. A vektorok egy adott típusú elemeket lineáris elrendezésben tárolnak, és lehetővé teszik a gyors véletlenszerű hozzáférést bármely elemhez. A vektor a sorozatok előnyben részesített tárolója, ha a véletlenszerű hozzáférésű teljesítmény prémium szinten van.

Szintaxis

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

Paraméterek

Type
A vektorban tárolandó elem adattípusa.

Allocator
Az a típus, amely a tárolt kiosztó objektumot jelöli, amely a vektor memóriafoglalásának és felszabadításának részleteit foglalja magában. Ez az argumentum nem kötelező, és az alapértelmezett érték allocator<Type>.

Megjegyzések

A vektorok lehetővé teszik az állandó idő beszúrását és törlését a sorozat végén. A vektor közepén lévő elemek beszúrása vagy törlése lineáris időt igényel. A deque osztály tároló gyorsabb a beszúráskor és a törlésnél a sorozat elején és végén. A list osztály tároló gyorsabb a beszúráskor és a törlésnél a sorozat bármely pontján.

A vektor újratelepítése akkor történik, ha egy tagfüggvénynek növelnie kell a vektorobjektumban található sorozatot a jelenlegi tárolókapacitásán túl. Más beszúrások és törlések megváltoztathatják a sorozaton belüli különböző tárolási címeket. Minden ilyen esetben érvénytelenek lesznek azok az iterátorok vagy hivatkozások, amelyek a sorozat módosított részeire mutatnak. Ha nem történik újratelepítés, csak a beszúrási/törlési pont előtti iterátorok és hivatkozások maradnak érvényesek.

A vector<bool> osztály a booltípusú elemek osztálysablonvektorának teljes specializációja. Rendelkezik egy kiosztóval a specializáció által használt mögöttes típushoz.

A vector<bool> referenciaosztály egy beágyazott osztály, amelynek objektumai hivatkozásokat adhatnak egy vector<bool> objektum elemeire (egy bitre).

Tagok

Konstruktorok

Név	Leírás
vector	Egy adott méretű vektort vagy egy adott érték elemeit, vagy egy adott allocator vagy más vektor másolatát hozza létre.

Typedefs

Név	Leírás
allocator_type	A vektorobjektum allocator osztályát jelképező típus.
const_iterator	Olyan típus, amely véletlenszerű hozzáférésű iterátort biztosít, amely képes beolvasni egy const elemet egy vektorban.
const_pointer	Olyan típus, amely mutatót ad egy vektor const eleméhez.
const_reference	Olyan típus, amely egy vektorban tárolt const elemre hivatkozik. Olvasásra és const műveletek végrehajtására szolgál.
const_reverse_iterator	Olyan típus, amely véletlenszerű hozzáférésű iterátort biztosít, amely képes beolvasni a vektor bármely const elemét.
difference_type	Egy vektor két elemének címe közötti különbséget biztosító típus.
iterator	Olyan típus, amely véletlenszerű hozzáférésű iterátort biztosít, amely képes olvasni vagy módosítani egy vektor bármely elemét.
pointer	Olyan típus, amely mutatót ad egy vektor egy eleméhez.
reference	Olyan típus, amely egy vektorban tárolt elemre mutató hivatkozást tartalmaz.
reverse_iterator	Olyan típus, amely véletlenszerű hozzáférésű iterátort biztosít, amely képes olvasni vagy módosítani egy fordított vektor bármely elemét.
size_type	Egy vektor elemeinek számát megszámláló típus.
value_type	Egy vektorban tárolt adattípust képviselő típus.

Funkciók

Név	Leírás
assign	Törli a vektort, és átmásolja a megadott elemeket az üres vektorba.
at	A vektor egy megadott helyén lévő elemre mutató hivatkozást ad vissza.
back	A vektor utolsó elemére mutató hivatkozást ad vissza.
begin	Véletlenszerű hozzáférésű iterátort ad vissza a vektor első eleméhez.
capacity	Azoknak az elemeknek a számát adja vissza, amelyeket a vektor tartalmazhat anélkül, hogy több tárterületet helyezne ki.
cbegin	Véletlenszerű hozzáférésű const iterátort ad vissza a vektor első eleméhez.
cend	Egy véletlenszerű hozzáférésű const iterátort ad vissza, amely a vektor végén túlra mutat.
crbegin	Egy konstans iterátort ad vissza egy fordított vektor első elemének.
crend	Egy fordított vektor végéhez tartozó const iterátort ad vissza.
clear	Törli a vektor elemeit.
data	A vektor első elemére mutató mutatót ad vissza.
emplace	A helyükön létrehozott elemet szúr be a vektorba egy megadott pozícióban.
emplace_back	A vektor végéhez egy helyben létrehozott elemet ad hozzá.
empty	Ellenőrzi, hogy a vektortároló üres-e.
end	Egy véletlenszerű hozzáférésű iterátort ad vissza, amely a vektor végére mutat.
erase	Eltávolít egy elemet vagy elemtartományt egy vektorban a megadott pozíciókból.
front	Egy vektor első elemére mutató hivatkozást ad vissza.
get_allocator	Egy objektumot ad vissza a vektor által használt allocator osztálynak.
insert	Elem vagy több elem beszúrása a vektorba egy megadott pozícióban.
max_size	A vektor maximális hosszát adja vissza.
pop_back	Törli az elemet a vektor végén.
push_back	Adjon hozzá egy elemet a vektor végéhez.
rbegin	Egy iterátort a fordított vektor első elemének ad vissza.
rend	Egy fordított vektor végéhez tartozó iterátort ad vissza.
reserve	Egy vektorobjektum minimális tárolási hosszát foglalja le.
resize	Egy vektor új méretét adja meg.
shrink_to_fit	Elveti a felesleges kapacitást.
size	A vektor elemeinek számát adja vissza.
swap	Két vektor elemeit cseréli le.

Piaci szereplők

Név	Leírás
operator[]	Egy adott pozícióban lévő vektorelemre mutató hivatkozást ad vissza.
operator=	A vektor elemeit lecseréli egy másik vektor másolatára.

allocator_type

Olyan típus, amely a vektorobjektum allokátorosztályát jelöli.

typedef Allocator allocator_type;

Megjegyzések

allocator_type a Allocatorsablonparaméter szinonimája.

Példa

A allocator_typehasználó példáért tekintse meg a get_allocator példáját.

assign

Törli a vektort, és átmásolja a megadott elemeket az üres vektorba.

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

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

Paraméterek

first
A másolandó elemek tartományának első elemének pozíciója.

last
Az első elem elhelyezése a másolandó elemek tartományán túl.

count
A vektorba beszúrt elem másolatainak száma.

value
A vektorba beszúrt elem értéke.

init_list
A beszúrni kívánt elemeket tartalmazó initializer_list.

Megjegyzések

Először assign törli a vektor meglévő elemeit. Ezután assign beszúr egy adott elemtartományt az eredeti vektorból egy vektorba, vagy beszúr egy új megadott értékelem másolatát egy vektorba.

Példa

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

A vektor egy megadott helyén lévő elemre mutató hivatkozást ad vissza.

reference at(size_type position);

const_reference at(size_type position) const;

Paraméterek

position
A vektorban hivatkozni kívánt elem alsó indexe vagy pozíciószáma.

Visszaadott érték

Hivatkozás az argumentumban alsó indexelt elemre. Ha position nagyobb, mint a vektor mérete, at kivételt jelez.

Megjegyzések

Ha a at visszatérési értéke egy const_referencevan hozzárendelve, a vektorobjektum nem módosítható. Ha a at visszatérési értéke egy referencevan hozzárendelve, a vektorobjektum módosítható.

Példa

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

A vektor utolsó elemére mutató hivatkozást ad vissza.

reference back();

const_reference back() const;

Visszaadott érték

A vektor utolsó eleme. Ha a vektor üres, a visszatérési érték nincs meghatározva.

Megjegyzések

Ha a back visszatérési értéke egy const_referencevan hozzárendelve, a vektorobjektum nem módosítható. Ha a back visszatérési értéke egy referencevan hozzárendelve, a vektorobjektum módosítható.

Az 1 vagy 2 _ITERATOR_DEBUG_LEVEL használatával történő fordításkor futásidejű hiba lép fel, ha üres vektor egy eleméhez próbál hozzáférni. További információ: Ellenőrzött iterátorok.

Példa

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

Véletlenszerű hozzáférésű iterátort ad vissza a vektor első eleméhez.

const_iterator begin() const;

iterator begin();

Visszaadott érték

Egy véletlenszerű hozzáférésű iterátor, amely a vector első elemét vagy egy üres vectorkövető helyre címez. Mindig hasonlítsa össze a visszaadott értéket vector::end annak érvényességéhez.

Megjegyzések

Ha a begin visszatérési értéke egy vector::const_iteratorvan hozzárendelve, a vector objektum nem módosítható. Ha a begin visszatérési értéke egy vector::iteratorvan hozzárendelve, a vector objektum módosítható.

Példa

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

Azoknak az elemeknek a számát adja vissza, amelyeket a vektor tartalmazhat anélkül, hogy több tárterületet helyezne ki.

size_type capacity() const;

Visszaadott érték

A vektor számára lefoglalt tárterület aktuális hossza.

Megjegyzések

A tagfüggvény resize hatékonyabb lesz, ha elegendő memória van lefoglalva ahhoz, hogy elférjen. A lefoglalt memória mennyiségének megadásához használja a reserve tagfüggvényt.

Példa

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

Egy const iterátort ad vissza, amely a tartomány első elemét kezeli.

const_iterator cbegin() const;

Visszaadott érték

Egy const véletlenszerű hozzáférésű iterátor, amely a tartomány első elemére mutat, vagy az üres tartomány végén túl eső helyre (üres tartomány esetén cbegin() == cend()).

Megjegyzések

A cbeginvisszatérési értékével a tartomány elemei nem módosíthatók.

Ezt a tagfüggvényt a begin() tagfüggvény helyett használhatja annak garantálásához, hogy a visszatérési érték const_iterator. Általában a auto típusú levonási kulcsszóval használják, ahogy az alábbi példában is látható. A példában a Container egy módosítható (nem const) tárolónak tekinti, amely támogatja a begin() és cbegin().

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

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

cend

Egy const végponton kívüli iterátort ad vissza, amely a vektor utolsó elemét követő elemre mutat.

const_iterator cend() const;

Visszaadott érték

A vektor const véges iterátora. A vektor utolsó elemét követő elemre mutat. Ez az elem helyőrző, és nem szabad elhatároltnak lennie. Csak összehasonlításhoz használja. Ha a vektor üres, akkor vector::cend() == vector::cbegin().

Megjegyzések

cend annak ellenőrzésére szolgál, hogy egy iterátor teljesítette-e a tartomány végét.

Ezt a tagfüggvényt a end() tagfüggvény helyett használhatja annak garantálásához, hogy a visszatérési érték const_iterator. Általában a auto típusú levonás kulcsszóval használják, ahogy az az alábbi példában is látható. A példában a Container egy módosítható (nem const) tárolónak tekinti, amely támogatja a end() és cend().

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

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

A cend által visszaadott értéket nem szabad elhalasztani. Csak összehasonlításhoz használja.

clear

Törli a vektor elemeit.

void clear();

Példa

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

Olyan típus, amely véletlenszerű hozzáférésű iterátort biztosít, amely képes beolvasni egy const elemet egy vektorban.

typedef implementation-defined const_iterator;

Megjegyzések

Egy const_iterator típus nem használható elem értékének módosítására.

Példa

A const_iteratorhasznált példához tekintse meg a vissza példában.

const_pointer

Olyan típus, amely mutatót ad egy vektor const eleméhez.

typedef typename Allocator::const_pointer const_pointer;

Megjegyzések

Egy const_pointer típus nem használható elem értékének módosítására.

Az iterátor gyakrabban használják vektorelemek eléréséhez.

const_reference

Olyan típus, amely egy vektorban tárolt const elemre hivatkozik. Olvasásra és const műveletek végrehajtására szolgál.

typedef typename Allocator::const_reference const_reference;

Megjegyzések

Egy const_reference típus nem használható elem értékének módosítására.

Példa

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

Olyan típus, amely véletlenszerű hozzáférésű iterátort biztosít, amely képes beolvasni a vektor bármely const elemét.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Megjegyzések

Egy const_reverse_iterator típus nem tudja módosítani egy elem értékét, és fordított vektoron keresztüli iterálásra szolgál.

Példa

Az iterátor deklarálásához és használatához lásd rbegin egy példát.

crbegin

Egy konstans iterátort ad vissza egy fordított vektor első elemének.

const_reverse_iterator crbegin() const;

Visszaadott érték

Egy fordított, véletlenszerű hozzáférésű iterátor, amely egy fordított vector első elemét kezeli, vagy a vissza nem fordított vectorutolsó elemét kezeli.

Megjegyzések

A crbeginvisszatérési értékével a vector objektum nem módosítható.

Példa

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

Egy const végponton kívüli fordított iterátort ad vissza, amely a fordított vektor utolsó elemét követő elemre mutat.

const_reverse_iterator crend() const;

Visszaadott érték

A fordított vektor const fordított, a végponton kívüli iterátor. A fordított vektor utolsó elemét követő elemre mutat, amely megegyezik a nem fordított vektor első eleme előtti elemével. Ez az elem helyőrző, és nem szabad elhatároltnak lennie. Csak összehasonlításhoz használja.

Megjegyzések

crend fordított vector használ, ugyanúgy, mint vector::cendvector.

A crend visszatérési értékével (megfelelően csökkentve) a vector objektum nem módosítható.

crend segítségével tesztelhető, hogy a fordított iterátor elérte-e a vectorvégét.

A crend által visszaadott értéket nem szabad elhalasztani. Csak összehasonlításhoz használja.

Példa

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

A vektor első elemére mutató mutatót ad vissza.

const_pointer data() const;

pointer data();

Visszaadott érték

Mutató a vector első elemére vagy arra a helyre, ahol egy üres vector.

Példa

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

Olyan típus, amely két olyan iterátor közötti különbséget biztosít, amelyek ugyanazon vektor elemeire hivatkoznak.

typedef typename Allocator::difference_type difference_type;

Megjegyzések

A difference_type a két mutató közötti elemek számának is nevezhető, mivel egy elem mutatója tartalmazza a címét.

Az iterátor gyakrabban használják vektorelemek eléréséhez.

Példa

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

A helyükön létrehozott elemet szúr be a vektorba egy megadott pozícióban.

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

Paraméterek

position
A vector az első elem beszúrásának helye.

args
Konstruktor argumentumok. A függvény arra következtet, hogy melyik konstruktort kell meghívni a megadott argumentumok alapján.

Visszaadott érték

A függvény egy iterátort ad vissza, amely arra a helyre mutat, ahol az új elemet beszúrták a vector.

Megjegyzések

A beszúrási műveletek költségesek lehetnek, vector osztály a vector teljesítményével kapcsolatos vitafórumban.

Példa

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

A vektor végéhez egy helyben létrehozott elemet ad hozzá.

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

Paraméterek

args
Konstruktor argumentumok. A függvény arra következtet, hogy melyik konstruktort kell meghívni a megadott argumentumok alapján.

Példa

#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

Ellenőrzi, hogy a vektor üres-e.

bool empty() const;

Visszaadott érték

true, ha a vektor üres; false, ha a vektor nem üres.

Példa

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

Egy múltbeli iterátort ad vissza, amely a vektor utolsó elemét követő elemre mutat.

iterator end();

const_iterator end() const;

Visszaadott érték

A vektor múltbeli iterátora. A vektor utolsó elemét követő elemre mutat. Ez az elem helyőrző, és nem szabad elhatároltnak lennie. Csak összehasonlításhoz használja. Ha a vektor üres, akkor vector::end() == vector::begin().

Megjegyzések

Ha a end visszatérési értéke const_iteratortípusú változóhoz van rendelve, a vektorobjektum nem módosítható. Ha a end visszatérési értéke iteratortípusú változóhoz van rendelve, a vektorobjektum módosítható.

Példa

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

Eltávolít egy elemet vagy elemtartományt egy vektorban a megadott pozíciókból.

iterator erase(
    const_iterator position);

iterator erase(
    const_iterator first,
    const_iterator last);

Paraméterek

position
A vektorból eltávolítandó elem pozíciója.

first
A vektorból eltávolított első elem pozíciója.

last
Pozíció a vektorból eltávolított utolsó elemen túl.

Visszaadott érték

Olyan iterátor, amely kijelöli az eltávolított elemeken túl fennmaradó első elemet, vagy ha nincs ilyen elem, a vektor végéhez mutató mutató.

Példa

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

Egy vektor első elemére mutató hivatkozást ad vissza.

reference front();

const_reference front() const;

Visszaadott érték

Hivatkozás a vektorobjektum első elemére. Ha a vektor üres, a visszatérés nem definiált.

Megjegyzések

Ha a front visszatérési értéke egy const_referencevan hozzárendelve, a vektorobjektum nem módosítható. Ha a front visszatérési értéke egy referencevan hozzárendelve, a vektorobjektum módosítható.

Az 1 vagy 2 _ITERATOR_DEBUG_LEVEL használatával történő fordításkor futásidejű hiba lép fel, ha üres vektor egy eleméhez próbál hozzáférni. További információ: Ellenőrzött iterátorok.

Példa

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

A vektor létrehozásához használt kiosztó objektum másolatát adja vissza.

Allocator get_allocator() const;

Visszaadott érték

A vektor által használt kiosztó.

Megjegyzések

A vektorosztály kiosztói határozzák meg, hogy az osztály hogyan kezeli a tárolást. A C++ standard kódtár-tárolóosztályokhoz megadott alapértelmezett kiosztók elegendőek a legtöbb programozási igényhez. A saját kiosztóosztály írása és használata egy speciális C++ funkció.

Példa

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

Elem vagy több elem vagy elemtartomány beszúrása a vektorba egy adott pozícióban.

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

Paraméterek

position
A vektor azon pozíciója, amelyben az első elem be van szúrva.

value
A vektorba beszúrt elem értéke.

count
A vektorba beszúrt elemek száma.

first
A másolandó elemek tartományának első elemének pozíciója.

last
Az első elem helye a másolandó elemek tartományán túl.

Visszaadott érték

Az első két insert függvény egy iterátort ad vissza, amely arra a helyre mutat, ahol az új elemet beszúrták a vektorba.

Megjegyzések

Előfeltételként first és last nem lehetnek iterátorok a vektorban, vagy a viselkedés nem definiált. A beszúrási műveletek költségesek lehetnek, vector osztály a vector teljesítményével kapcsolatos vitafórumban.

Példa

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

Olyan típus, amely véletlenszerű hozzáférésű iterátort biztosít, amely képes olvasni vagy módosítani egy vektor bármely elemét.

typedef implementation-defined iterator;

Megjegyzések

Egy elem értékének módosítására iterator típus használható.

Példa

Lásd a példát a begin.

max_size

A vektor maximális hosszát adja vissza.

size_type max_size() const;

Visszaadott érték

A vektor lehetséges maximális hossza.

Példa

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

Egy adott pozícióban lévő vektorelemre mutató hivatkozást ad vissza.

reference operator[](size_type position);

const_reference operator[](size_type position) const;

Paraméterek

position
A vektorelem helyzete.

Visszaadott érték

Ha a megadott pozíció nagyobb vagy egyenlő a tároló méretével, az eredmény nincs meghatározva.

Megjegyzések

Ha a operator[] visszatérési értéke egy const_referencevan hozzárendelve, a vektorobjektum nem módosítható. Ha a operator[] visszatérési értéke egy hivatkozáshoz van rendelve, a vektorobjektum módosítható.

Az 1 vagy 2 _ITERATOR_DEBUG_LEVEL használatával történő fordításkor futásidejű hiba lép fel, ha a vektor határain kívüli elemet próbál elérni. További információ: Ellenőrzött iterátorok.

Példa

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

A vektor elemeit lecseréli egy másik vektor másolatára.

vector& operator=(const vector& right);

vector& operator=(vector&& right);

Paraméterek

right
A vector a vector.

Megjegyzések

A vectormeglévő elemeinek törlése után operator= másolhatja vagy áthelyezheti a right tartalmát a vector.

Példa

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

Olyan típus, amely mutatót ad egy vektor egy eleméhez.

typedef typename Allocator::pointer pointer;

Megjegyzések

Egy elem értékének módosítására pointer típus használható.

Példa

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

Törli az elemet a vektor végén.

void pop_back();

Megjegyzések

Példakód: vektor::p ush_back().

push_back

Hozzáad egy elemet a vektor végéhez.

void push_back(const T& value);

void push_back(T&& value);

Paraméterek

value
A vektor végéhez hozzáadott elemhez hozzárendelendő érték.

Példa

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

Egy iterátort a fordított vektor első elemének ad vissza.

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

Visszaadott érték

Fordított véletlenszerű hozzáférésű iterátor, amely egy fordított vektor első elemét kezeli, vagy a fordított vektor utolsó elemét kezeli.

Megjegyzések

Ha a rbegin visszatérési értéke egy const_reverse_iteratorvan hozzárendelve, a vektorobjektum nem módosítható. Ha a rbegin visszatérési értéke egy reverse_iteratorvan hozzárendelve, a vektorobjektum módosítható.

Példa

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

Olyan típus, amely egy vektorban tárolt elemre mutató hivatkozást tartalmaz.

typedef typename Allocator::reference reference;

Példa

Lásd at a reference vektorosztályban való használatára vonatkozó példát.

rend

Egy korábbi végű fordított iterátort ad vissza, amely a fordított vektor utolsó elemét követő elemre mutat.

const_reverse_iterator rend() const;
reverse_iterator rend();

Visszaadott érték

A fordított vektor végponti iterátorának megfordítása. A fordított vektor utolsó elemét követő elemre mutat, amely megegyezik a nem fordított vektor első eleme előtti elemével. Ez az elem helyőrző, és nem szabad elhatároltnak lennie. Csak összehasonlításhoz használja.

Megjegyzések

rend fordított vektorral használják, ugyanúgy, mint end egy vektorhoz.

Ha a rend visszatérési értéke egy const_reverse_iteratorvan hozzárendelve, akkor a vektorobjektum nem módosítható. Ha a rend visszatérési értéke egy reverse_iteratorvan hozzárendelve, akkor a vektorobjektum módosítható.

rend használható annak ellenőrzésére, hogy egy fordított iterátor elérte-e a vektor végét.

A rend által visszaadott értéket nem szabad elhalasztani. Csak összehasonlításhoz használja.

Példa

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

Egy vektorobjektum minimális tárolási hosszát foglalja le, szükség esetén helyet foglal el.

void reserve(size_type count);

Paraméterek

count
A vektor számára lefoglalandó tárterület minimális hossza.

Példa

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

Egy vektor új méretét adja meg.

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

Paraméterek

new_size
A vektor új mérete.

value
A vektorhoz hozzáadott új elemek inicializálási értéke, ha az új méret nagyobb, mint az eredeti méret. Ha az érték nincs megadva, az új objektumok az alapértelmezett konstruktort használják.

Megjegyzések

Ha a tároló mérete kisebb a kért méretnél, new_size, resize elemeket ad hozzá a vektorhoz, amíg el nem éri a kért méretet. Ha a tároló mérete nagyobb a kért méretnél, resize törli a tároló végéhez legközelebbi elemeket, amíg el nem éri a new_sizeméretet. Nem történik művelet, ha a tároló jelenlegi mérete megegyezik a kért méretével.

size a vektor aktuális méretét tükrözi.

Példa

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

Olyan típus, amely véletlenszerű hozzáférésű iterátort biztosít, amely képes olvasni vagy módosítani egy fordított vektor bármely elemét.

typedef std::reverse_iterator<iterator> reverse_iterator;

Megjegyzések

Egy reverse_iterator típus használatával a vektort fordított módon lehet iterálni.

Példa

Lásd a példát a rbegin.

shrink_to_fit

Elveti a felesleges kapacitást.

void shrink_to_fit();

Példa

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

A vektor elemeinek számát adja vissza.

size_type size() const;

Visszaadott érték

A vektor aktuális hossza.

Példa

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

Egy vektor elemeinek számát megszámláló típus.

typedef typename Allocator::size_type size_type;

Példa

Lásd a példát a capacity.

swap

Két vektor elemeit cseréli le.

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

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

Paraméterek

right
A felcserélni kívánt elemeket tartalmazó vektor. Vagy egy vektor, amelynek elemeit a vektor elemeivel kell kicserélni left.

left
Olyan vektor, amelynek elemeit a vektor elemeivel kell kicserélni right.

Példa

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

Egy vektorban tárolt adattípust képviselő típus.

typedef typename Allocator::value_type value_type;

Megjegyzések

value_type a Typesablonparaméter szinonimája.

Példa

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

Vektort hoz létre. A túlterhelések egy adott méretű vektort vagy egy adott érték elemeit építik ki. Vagy más vektor egészének vagy egy részének másolataként. Egyes túlterhelések lehetővé teszik a használni kívánt kiosztó megadását is.

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

Paraméterek

allocator
Az objektumhoz használni kívánt kiosztóosztály. get_allocator az objektum kiosztóosztályát adja vissza.

count
A létrehozott vektor elemeinek száma.

value
A létrehozott vektor elemeinek értéke.

source
Az a vektor, amelynek a létrehozott vektora másolat.

first
A másolandó elemek tartományának első elemének pozíciója.

last
Az első elem elhelyezése a másolandó elemek tartományán túl.

init_list
A másolandó elemeket tartalmazó initializer_list.

Megjegyzések

Minden konstruktor tárol egy allokátorobjektumot (allocator), és inicializálja a vektort.

Az első két konstruktor üres kezdeti vektort ad meg. A második konstruktor explicit módon meghatározza a használni kívánt kiosztótípust (allocator).

A harmadik konstruktor a Typeosztály alapértelmezett értékének elemeinek megadott számának (count) ismétlődését adja meg.

A negyedik és ötödik konstruktorok az valueérték elemeinek (count) ismétlődését határozzák meg.

A hatodik konstruktor a vektor sourceegy példányát adja meg.

A hetedik konstruktor mozgatja a vektort source.

A nyolcadik konstruktor egy initializer_list használ az elemek megadásához.

A kilencedik és a tizedik konstruktorok egy vektor [first, last) tartományát másolja.

Példa

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

Lásd még:

Szálbiztonság a C++ Standard könyvtárban
C++ standard kódtár referencia-