Klasa `vector`

Artykuł
09/02/2023

Klasa wektorowa biblioteki standardowej języka C++ jest szablonem klasy dla kontenerów sekwencji. Wektor przechowuje elementy danego typu w układzie liniowym i umożliwia szybki losowy dostęp do dowolnego elementu. Wektor jest preferowanym kontenerem dla sekwencji, gdy wydajność dostępu losowego jest w warstwie Premium.

Składnia

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

Parametry

Type
Typ danych elementu, który ma być przechowywany w wektorze

Allocator
Typ reprezentujący przechowywany obiekt alokatora, który hermetyzuje szczegóły dotyczące alokacji wektora i cofnięcia alokacji pamięci. Ten argument jest opcjonalny, a wartość domyślna to allocator<Type>.

Uwagi

Wektory umożliwiają stałe wstawianie i usuwanie czasu na końcu sekwencji. Wstawianie lub usuwanie elementów w środku wektora wymaga czasu liniowego. Kontener deque klas jest szybszy podczas wstawiania i usuwania na początku i na końcu sekwencji. Kontener list klasy jest szybszy w przypadku wstawiania i usuwania w dowolnej lokalizacji w ramach sekwencji.

Reallocation wektora występuje, gdy funkcja składowa musi zwiększyć sekwencję zawartą w obiekcie wektorowym poza bieżącą pojemnością magazynu. Inne wstawiania i wymazywania mogą zmieniać różne adresy magazynu w sekwencji. We wszystkich takich przypadkach iteratory lub odwołania wskazujące na zmienione części sekwencji stają się nieprawidłowe. Jeśli nie ma miejsca rzeczywistego, tylko iteratory i odwołania przed punktem wstawiania/usuwania pozostają prawidłowe.

Klasa vector<bool> jest pełną specjalizacją wektora szablonu klasy dla elementów typu bool. Ma alokator dla typu bazowego używanego przez specjalizację.

Klasa referencyjna vector<bool> to zagnieżdżona klasa , której obiekty mogą dostarczać odwołania do elementów (pojedynczych bitów) w vector<bool> obiekcie.

Członkowie

Konstruktory

Nazwa/nazwisko	opis
`vector`	Konstruuje wektor określonego rozmiaru lub z elementami określonej wartości albo z określoną `allocator` lub jako kopię innego wektora.

Typedefs

Nazwa/nazwisko	opis
`[allocator_type]`(#allocator_type)	Typ reprezentujący klasę `allocator` dla obiektu wektorowego.
`const_iterator`	Typ, który udostępnia iterator dostępu losowego, który może odczytać `const` element w wektorze.
`const_pointer`	Typ, który dostarcza wskaźnik do `const` elementu w wektorze.
`const_reference`	Typ, który zawiera odwołanie do `const` elementu przechowywanego w wektorze. Służy do odczytywania i wykonywania `const` operacji.
`const_reverse_iterator`	Typ, który udostępnia iterator dostępu losowego, który może odczytywać dowolny `const` element w wektorze.
`difference_type`	Typ, który zapewnia różnicę między adresami dwóch elementów w wektorze.
`iterator`	Typ, który udostępnia iterator dostępu losowego, który może odczytywać lub modyfikować dowolny element w wektorze.
`pointer`	Typ, który dostarcza wskaźnik do elementu w wektorze.
`reference`	Typ, który zawiera odwołanie do elementu przechowywanego w wektorze.
`reverse_iterator`	Typ, który udostępnia iterator dostępu losowego, który może odczytywać lub modyfikować dowolny element w wektorze odwróconym.
`size_type`	Typ, który zlicza liczbę elementów w wektorze.
`value_type`	Typ reprezentujący typ danych przechowywany w wektorze.

Funkcje

Nazwa/nazwisko	opis
`assign`	Usuwa wektor i kopiuje określone elementy do pustego wektora.
`at`	Zwraca odwołanie do elementu w określonej lokalizacji w wektorze.
`back`	Zwraca odwołanie do ostatniego elementu wektora.
`begin`	Zwraca iterator dostępu losowego do pierwszego elementu w wektorze.
`capacity`	Zwraca liczbę elementów, które może zawierać wektor bez przydzielania większej ilości miejsca do magazynowania.
`cbegin`	Zwraca iterator const dostępu losowego do pierwszego elementu w wektorze.
`cend`	Zwraca iterator const dostępu losowego, który wskazuje tuż poza końcem wektora.
`crbegin`	Zwraca iterator const do pierwszego elementu w wektorze odwróconym.
`crend`	Zwraca iterator const na końcu odwróconego wektora.
`clear`	Usuwa elementy wektora.
`data`	Zwraca wskaźnik do pierwszego elementu w wektorze.
`emplace`	Wstawia element skonstruowany w miejscu do wektora w określonej pozycji.
`emplace_back`	Dodaje element skonstruowany na końcu wektora.
`empty`	Sprawdza, czy kontener wektorowy jest pusty.
`end`	Zwraca iterator dostępu losowego, który wskazuje na koniec wektora.
`erase`	Usuwa element lub zakres elementów w wektorze z określonych pozycji.
`front`	Zwraca odwołanie do pierwszego elementu w wektorze.
`get_allocator`	Zwraca obiekt do `allocator` klasy używanej przez wektor.
`insert`	Wstawia element lub wiele elementów do wektora w określonej pozycji.
`max_size`	Zwraca maksymalną długość wektora.
`pop_back`	Usuwa element na końcu wektora.
`push_back`	Dodaj element na końcu wektora.
`rbegin`	Zwraca iterator do pierwszego elementu w odwróconym wektorze.
`rend`	Zwraca iterator na końcu odwróconego wektora.
`reserve`	Rezerwuje minimalną długość magazynu dla obiektu wektorowego.
`resize`	Określa nowy rozmiar wektora.
`shrink_to_fit`	Odrzuca nadmiarową pojemność.
`size`	Zwraca liczbę elementów w wektorze.
`swap`	Wymienia elementy dwóch wektorów.

Operatory

Nazwa/nazwisko	opis
`operator[]`	Zwraca odwołanie do elementu wektora na określonej pozycji.
`operator=`	Zastępuje elementy wektora kopią innego wektora.

`allocator_type`

Typ reprezentujący klasę alokatora dla obiektu wektorowego.

typedef Allocator allocator_type;

Uwagi

allocator_type jest synonimem parametru Allocatorszablonu .

Przykład

Zobacz przykład, aby get_allocator zapoznać się z przykładem, który używa elementu allocator_type.

`assign`

Usuwa wektor i kopiuje określone elementy do pustego wektora.

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
Pozycja pierwszego elementu w zakresie elementów do skopiowania.

last
Położenie pierwszego elementu poza zakresem elementów do skopiowania.

count
Liczba kopii elementu wstawionego do wektora.

value
Wartość elementu wstawionego do wektora.

init_list
Initializer_list zawierające elementy do wstawienia.

Uwagi

assign Najpierw usuwa wszystkie istniejące elementy w wektorze. assign Następnie wstawia określony zakres elementów z oryginalnego wektora do wektora lub wstawia kopie nowego określonego elementu wartości do wektora.

Przykład

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

Zwraca odwołanie do elementu w określonej lokalizacji w wektorze.

reference at(size_type position);

const_reference at(size_type position) const;

Parametry

position
Indeks dolny lub numer położenia elementu do odwołania w wektorze.

Wartość zwracana

Odwołanie do elementu w indeksie dolnym argumentu. Jeśli position jest większy niż rozmiar wektora, at zgłasza wyjątek.

Uwagi

Jeśli wartość zwracana at elementu jest przypisana do const_referenceobiektu , nie można zmodyfikować obiektu wektorowego. Jeśli zwracana wartość at elementu jest przypisana do referenceobiektu , można zmodyfikować obiekt wektorowy.

Przykład

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

Zwraca odwołanie do ostatniego elementu wektora.

reference back();

const_reference back() const;

Wartość zwracana

Ostatni element wektora. Jeśli wektor jest pusty, wartość zwracana jest niezdefiniowana.

Uwagi

Jeśli wartość zwracana back elementu jest przypisana do const_referenceobiektu , nie można zmodyfikować obiektu wektorowego. Jeśli zwracana wartość back elementu jest przypisana do referenceobiektu , można zmodyfikować obiekt wektorowy.

Podczas kompilowania przy użyciu _ITERATOR_DEBUG_LEVEL zdefiniowanego jako 1 lub 2 błąd środowiska uruchomieniowego występuje, jeśli próbujesz uzyskać dostęp do elementu w pustym wektorze. Aby uzyskać więcej informacji, zobacz Sprawdzono iteratory.

Przykład

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

Zwraca iterator dostępu losowego do pierwszego elementu w wektorze.

const_iterator begin() const;

iterator begin();

Wartość zwracana

Iterator dostępu losowego odnoszący się do pierwszego elementu w vector lokalizacji lub kończy się powodzeniem pustego vectorelementu . Zawsze porównaj zwróconą wartość z vector::end , aby upewnić się, że jest ona prawidłowa.

Uwagi

Jeśli zwracana wartość begin elementu jest przypisana do vector::const_iteratorobiektu , vector nie można zmodyfikować obiektu. Jeśli wartość zwracana begin elementu jest przypisana do vector::iteratorobiektu , vector można go zmodyfikować.

Przykład

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

Zwraca liczbę elementów, które może zawierać wektor bez przydzielania większej ilości miejsca do magazynowania.

size_type capacity() const;

Wartość zwracana

Bieżąca długość magazynu przydzielonego dla wektora.

Uwagi

Funkcja resize składowa będzie bardziej wydajna, jeśli zostanie przydzielona wystarczająca ilość pamięci, aby ją pomieścić. Użyj funkcji reserve składowej, aby określić ilość przydzielonej pamięci.

Przykład

// 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 Zwraca iterator, który adresuje pierwszy element w zakresie.

const_iterator cbegin() const;

Wartość zwracana

const Iterator dostępu losowego, który wskazuje pierwszy element zakresu lub lokalizację tuż poza końcem pustego zakresu (dla pustego zakresu, cbegin() == cend()).

Uwagi

Przy zwracanej wartości cbeginelementu nie można modyfikować elementów w zakresie.

Możesz użyć tej funkcji składowej zamiast funkcji składowej begin() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest on używany z auto słowem kluczowym odliczenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niż const) jakiegokolwiek rodzaju, który obsługuje begin() i cbegin().

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

// i2 is Container<T>::const_iterator

`cend`

const Zwraca iterator przeszłości,który wskazuje element po ostatnim elemektorze.

const_iterator cend() const;

Wartość zwracana

const Iterator poza końcem dla wektora. Wskazuje element na ostatni element wektora. Ten element jest symbolem zastępczym i nie powinien być wyłuszony. Należy używać go tylko do porównań. Jeśli wektor jest pusty, to vector::cend() == vector::cbegin().

Uwagi

cend służy do testowania, czy iterator przeszedł koniec jego zakresu.

Możesz użyć tej funkcji składowej zamiast funkcji składowej end() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niż const) jakiegokolwiek rodzaju, który obsługuje end() i cend().

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

// i2 is Container<T>::const_iterator

Wartość zwracana przez cend nie powinna być wyłuszczone. Należy używać go tylko do porównań.

`clear`

Usuwa elementy wektora.

void clear();

Przykład

// 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, który udostępnia iterator dostępu losowego, który może odczytać const element w wektorze.

typedef implementation-defined const_iterator;

Uwagi

Nie można użyć typu const_iterator do modyfikowania wartości elementu.

Przykład

Zobacz przykład z powrotem, aby zapoznać się z przykładem, który używa elementu const_iterator.

`const_pointer`

Typ, który dostarcza wskaźnik do const elementu w wektorze.

typedef typename Allocator::const_pointer const_pointer;

Uwagi

Nie można użyć typu const_pointer do modyfikowania wartości elementu.

Iterator jest częściej używany do uzyskiwania dostępu do elementu wektora.

`const_reference`

Typ, który zawiera odwołanie do const elementu przechowywanego w wektorze. Służy do odczytywania i wykonywania const operacji.

typedef typename Allocator::const_reference const_reference;

Uwagi

Nie można użyć typu const_reference do modyfikowania wartości elementu.

Przykład

// 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, który udostępnia iterator dostępu losowego, który może odczytywać dowolny const element w wektorze.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Uwagi

Typ const_reverse_iterator nie może modyfikować wartości elementu i jest używany do iterowania wektora odwrotnie.

Przykład

Zobacz rbegin przykład sposobu deklarowania i używania iteratora.

`crbegin`

Zwraca iterator const do pierwszego elementu w wektorze odwróconym.

const_reverse_iterator crbegin() const;

Wartość zwracana

Iterator const reverse random-access odnoszący się do pierwszego elementu w odwróconym vector lub odnoszącym się do tego, co było ostatnim elementem w niereversed .vector

Uwagi

Przy użyciu wartości zwracanej crbeginvector obiektu nie można modyfikować.

Przykład

// 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 Zwraca iterator odwrotny z przeszłości, który wskazuje element po ostatnim elemenie wektora odwróconego.

const_reverse_iterator crend() const;

Wartość zwracana

Odwrotny const iterator odwrotny dla wektora odwróconego. Wskazuje element na ostatni element wektora odwróconego, który jest taki sam jak element przed pierwszym elementem wektora nieodwrótnego. Ten element jest symbolem zastępczym i nie powinien być wyłuszony. Należy używać go tylko do porównań.

Uwagi

crend jest używany z odwróconym vector elementem, tak jak vector::cend jest używany z elementem vector.

Przy użyciu wartości zwracanej crend (odpowiednio zdekrementowanej) vector nie można zmodyfikować obiektu.

crend można użyć do sprawdzenia, czy iterator odwrotny osiągnął koniec jego vector.

Wartość zwracana przez crend nie powinna być wyłuszczone. Należy używać go tylko do porównań.

Przykład

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

Zwraca wskaźnik do pierwszego elementu w wektorze.

const_pointer data() const;

pointer data();

Wartość zwracana

Wskaźnik do pierwszego elementu w vector lokalizacji lub kończy się powodzeniem pustego vectorelementu .

Przykład

// 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, który zapewnia różnicę między dwoma iteratorami odwołującymi się do elementów w tym samym wektorze.

typedef typename Allocator::difference_type difference_type;

Uwagi

Element difference_type można również opisać jako liczbę elementów między dwoma wskaźnikami, ponieważ wskaźnik do elementu zawiera jego adres.

Iterator jest częściej używany do uzyskiwania dostępu do elementu wektora.

Przykład

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

Wstawia element skonstruowany w miejscu do wektora w określonej pozycji.

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

Parametry

position
Położenie w miejscu, w vector którym jest wstawiany pierwszy element.

args
Argumenty konstruktora. Funkcja wywnioskuje, które przeciążenie konstruktora ma być wywoływane na podstawie podanych argumentów.

Wartość zwracana

Funkcja zwraca iterator wskazujący położenie, w którym nowy element został wstawiony do elementu vector.

Uwagi

Każda operacja wstawiania może być kosztowna, zobacz vector klasę , aby zapoznać się z vector omówieniem wydajności.

Przykład

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

Dodaje element skonstruowany na końcu wektora.

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

Parametry

args
Argumenty konstruktora. Funkcja wywnioskuje, które przeciążenie konstruktora ma być wywoływane na podstawie podanych argumentów.

Przykład

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

Sprawdza, czy wektor jest pusty.

bool empty() const;

Wartość zwracana

true jeśli wektor jest pusty; false jeśli wektor nie jest pusty.

Przykład

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

Zwraca iterator przeszłości,który wskazuje element po ostatnim elemektorze.

iterator end();

const_iterator end() const;

Wartość zwracana

Iterator poza końcem dla wektora. Wskazuje element na ostatni element wektora. Ten element jest symbolem zastępczym i nie powinien być wyłuszony. Należy używać go tylko do porównań. Jeśli wektor jest pusty, to vector::end() == vector::begin().

Uwagi

Jeśli wartość zwracana end klasy jest przypisana do zmiennej typu const_iterator, nie można zmodyfikować obiektu wektorowego. Jeśli wartość zwracana end klasy jest przypisywana do zmiennej typu iterator, można zmodyfikować obiekt wektorowy.

Przykład

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

Usuwa element lub zakres elementów w wektorze z określonych pozycji.

iterator erase(
    const_iterator position);

iterator erase(
    const_iterator first,
    const_iterator last);

Parametry

position
Położenie elementu do usunięcia z wektora.

first
Położenie pierwszego elementu usuniętego z wektora.

last
Pozycja tuż poza ostatnim elementem usuniętym z wektora.

Wartość zwracana

Iterator, który wyznacza pierwszy element pozostały poza usuniętymi elementami lub wskaźnik na końcu wektora, jeśli taki element nie istnieje.

Przykład

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

Zwraca odwołanie do pierwszego elementu w wektorze.

reference front();

const_reference front() const;

Wartość zwracana

Odwołanie do pierwszego elementu w obiekcie wektorowym. Jeśli wektor jest pusty, zwracanie jest niezdefiniowane.

Uwagi

Jeśli wartość zwracana front elementu jest przypisana do const_referenceobiektu , nie można zmodyfikować obiektu wektorowego. Jeśli zwracana wartość front elementu jest przypisana do referenceobiektu , można zmodyfikować obiekt wektorowy.

Przykład

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

Zwraca kopię obiektu alokatora używanego do konstruowania wektora.

Allocator get_allocator() const;

Wartość zwracana

Alokator używany przez wektor.

Uwagi

Alokatory dla klasy wektorowej określają sposób zarządzania magazynem przez klasę. Domyślne alokatory dostarczane z klasami kontenerów biblioteki standardowej języka C++ są wystarczające dla większości potrzeb programistycznych. Pisanie i używanie własnej klasy alokatora to zaawansowana funkcja języka C++.

Przykład

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

Wstawia element lub wiele elementów albo zakres elementów do wektora w określonej pozycji.

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
Położenie wektora, w którym wstawiono pierwszy element.

value
Wartość elementu wstawionego do wektora.

count
Liczba elementów wstawionych do wektora.

first
Położenie pierwszego elementu w zakresie elementów do skopiowania.

last
Położenie pierwszego elementu poza zakresem elementów do skopiowania.

Wartość zwracana

Pierwsze dwie insert funkcje zwracają iterator wskazujący położenie, w którym nowy element został wstawiony do wektora.

Uwagi

Jako warunek wstępny i firstlast nie może być iteratorami do wektora lub zachowanie jest niezdefiniowane. Każda operacja wstawiania może być kosztowna, zobacz vector klasę , aby zapoznać się z vector omówieniem wydajności.

Przykład

// 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, który udostępnia iterator dostępu losowego, który może odczytywać lub modyfikować dowolny element w wektorze.

typedef implementation-defined iterator;

Uwagi

iterator Typ może służyć do modyfikowania wartości elementu.

Przykład

Zobacz przykład dla elementu begin.

`max_size`

Zwraca maksymalną długość wektora.

size_type max_size() const;

Wartość zwracana

Maksymalna możliwa długość wektora.

Przykład

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

Zwraca odwołanie do elementu wektora na określonej pozycji.

reference operator[](size_type position);

const_reference operator[](size_type position) const;

Parametry

position
Położenie elementu wektora.

Wartość zwracana

Jeśli określona pozycja jest większa niż lub równa rozmiarowi kontenera, wynik jest niezdefiniowany.

Uwagi

Jeśli wartość zwracana operator[] elementu jest przypisana do const_referenceobiektu , nie można zmodyfikować obiektu wektorowego. Jeśli zwracana wartość operator[] elementu jest przypisana do odwołania, można zmodyfikować obiekt wektorowy.

Podczas kompilowania przy użyciu _ITERATOR_DEBUG_LEVEL zdefiniowanego jako 1 lub 2 błąd środowiska uruchomieniowego występuje, jeśli próbujesz uzyskać dostęp do elementu spoza granic wektora. Aby uzyskać więcej informacji, zobacz Sprawdzono iteratory.

Przykład

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

Zastępuje elementy wektora kopią innego wektora.

vector& operator=(const vector& right);

vector& operator=(vector&& right);

Parametry

right
Element vector kopiowany do pliku vector.

Uwagi

Po wymazaniu wszystkich istniejących elementów w obiekcie vectoroperator= element kopiuje lub przenosi zawartość right do elementu vector.

Przykład

// 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, który dostarcza wskaźnik do elementu w wektorze.

typedef typename Allocator::pointer pointer;

Uwagi

pointer Typ może służyć do modyfikowania wartości elementu.

Przykład

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

Usuwa element na końcu wektora.

void pop_back();

Uwagi

Aby zapoznać się z przykładem kodu, zobacz vector::p ush_back().

`push_back`

Dodaje element na końcu wektora.

void push_back(const T& value);

void push_back(T&& value);

Parametry

value
Wartość, która ma zostać przypisana do elementu dodanego na końcu wektora.

Przykład

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

Zwraca iterator do pierwszego elementu w odwróconym wektorze.

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

Wartość zwracana

Iterator odwrotnego dostępu losowego odnoszący się do pierwszego elementu w wektorze odwróconym lub odnoszący się do tego, co było ostatnim elementem w wektorze niewzreversed.

Uwagi

Jeśli wartość zwracana rbegin elementu jest przypisana do const_reverse_iteratorobiektu , nie można zmodyfikować obiektu wektorowego. Jeśli zwracana wartość rbegin elementu jest przypisana do reverse_iteratorobiektu , można zmodyfikować obiekt wektorowy.

Przykład

// 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, który zawiera odwołanie do elementu przechowywanego w wektorze.

typedef typename Allocator::reference reference;

Przykład

Zobacz at przykład użycia reference w klasie wektorowej.

`rend`

Zwraca iterator odwrotny z przeszłości, który wskazuje element po ostatnim elemenie wektora odwróconego.

const_reverse_iterator rend() const;
reverse_iterator rend();

Wartość zwracana

Odwrotny iterator odwrotny dla wektora odwróconego. Wskazuje element na ostatni element wektora odwróconego, który jest taki sam jak element przed pierwszym elementem wektora nieodwrótnego. Ten element jest symbolem zastępczym i nie powinien być wyłuszony. Należy używać go tylko do porównań.

Uwagi

rend jest używany z wektorem odwróconym, tak jak end jest używany z wektorem.

Jeśli wartość zwracana rend elementu jest przypisana do const_reverse_iteratorobiektu , nie można zmodyfikować obiektu wektora. Jeśli wartość zwracana rend elementu jest przypisana do reverse_iteratorobiektu , można zmodyfikować obiekt wektorowy.

rend można użyć do sprawdzenia, czy iterator odwrotny osiągnął koniec jego wektora.

Wartość zwracana przez rend nie powinna być wyłuszczone. Należy używać go tylko do porównań.

Przykład

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

Rezerwuje minimalną długość magazynu dla obiektu wektorowego, przydzielając miejsce w razie potrzeby.

void reserve(size_type count);

Parametry

count
Minimalna długość magazynu do przydzielenia dla wektora.

Przykład

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

Określa nowy rozmiar wektora.

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

Parametry

new_size
Nowy rozmiar wektora.

value
Wartość inicjowania nowych elementów dodanych do wektora, jeśli nowy rozmiar jest większy niż rozmiar oryginalny. Jeśli wartość zostanie pominięta, nowe obiekty używają ich konstruktora domyślnego.

Uwagi

Jeśli rozmiar kontenera jest mniejszy niż żądany rozmiar, new_sizeresize element dodaje elementy do wektora, dopóki nie osiągnie żądanego rozmiaru. Gdy rozmiar kontenera jest większy niż żądany rozmiar, resize usuwa elementy znajdujące się najbliżej końca kontenera, dopóki nie osiągnie rozmiaru new_size. Nie jest podejmowana żadna akcja, jeśli obecny rozmiar kontenera jest taki sam jak żądany rozmiar.

size odzwierciedla bieżący rozmiar wektora.

Przykład

// 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, który udostępnia iterator dostępu losowego, który może odczytywać lub modyfikować dowolny element w wektorze odwróconym.

typedef std::reverse_iterator<iterator> reverse_iterator;

Uwagi

Typ reverse_iterator służy do iterowania wektora odwrotnie.

Przykład

Zobacz przykład dla elementu rbegin.

`shrink_to_fit`

Odrzuca nadmiarową pojemność.

void shrink_to_fit();

Przykład

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

Zwraca liczbę elementów w wektorze.

size_type size() const;

Wartość zwracana

Bieżąca długość wektora.

Przykład

// 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, który zlicza liczbę elementów w wektorze.

typedef typename Allocator::size_type size_type;

Przykład

Zobacz przykład dla elementu capacity.

`swap`

Wymienia elementy dwóch wektorów.

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

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

Parametry

right
Wektor dostarczający elementy do zamiany. Lub wektor, którego elementy mają być wymieniane z elementami w wektorze left.

left
Wektor, którego elementy mają być wymieniane z elementami w wektorze right.

Przykład

// 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 reprezentujący typ danych przechowywany w wektorze.

typedef typename Allocator::value_type value_type;

Uwagi

value_type jest synonimem parametru Typeszablonu .

Przykład

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

int main( )
{
   using namespace std;
   vector<int>::value_type AnInt;
   AnInt = 44;
   cout << AnInt << endl;
}

`vector`

Tworzy wektor. Przeciążenia konstruuje wektor o określonym rozmiarze lub z elementami określonej wartości. Albo jako kopia wszystkich lub części innego wektora. Niektóre przeciążenia umożliwiają również określenie alokatora do użycia.

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
Klasa alokatora do wykorzystania z tym obiektem. get_allocator Zwraca klasę alokatora dla obiektu.

count
Liczba elementów w wektorze skonstruowanym.

value
Wartość elementów w skonstruowanym wektorze.

source
Wektor, którego skonstruowany wektor ma być kopią.

first
Pozycja pierwszego elementu w zakresie elementów do skopiowania.

last
Położenie pierwszego elementu poza zakresem elementów do skopiowania.

init_list
Element initializer_list zawierający elementy do skopiowania.

Uwagi

Wszystkie konstruktory przechowują obiekt alokatora (allocator) i inicjują wektor.

Dwa pierwsze konstruktory określają pusty wektor początkowy. Drugi konstruktor jawnie określa typ alokatora (allocator) do użycia.

Trzeci konstruktor określa powtórzenie określonej liczby (count) elementów wartości domyślnej dla klasy Type.

Czwarte i piąte konstruktory określają powtórzeniecount () elementów wartości value.

Szósty konstruktor określa kopię wektora source.

Siódmy konstruktor przenosi wektor source.

Ósmy konstruktor używa initializer_list do określenia elementów.

Dziewiąte i dziesiąte konstruktory kopiują zakres [first, last) wektora.

Przykład

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

Zobacz też

Bezpieczeństwo wątku w standardowej bibliotece C++
Dokumentacja standardowej biblioteki C++

Klasa vector

Składnia

Parametry

Uwagi

Członkowie

Konstruktory

Typedefs

Funkcje

Operatory

allocator_type

Uwagi

Przykład

assign

Parametry

Uwagi

Przykład

at

Parametry

Wartość zwracana

Uwagi

Przykład

back

Wartość zwracana

Uwagi

Przykład

begin

Wartość zwracana

Uwagi

Przykład

capacity

Wartość zwracana

Uwagi

Przykład

cbegin

Wartość zwracana

Uwagi

cend

Wartość zwracana

Uwagi

clear

Przykład

const_iterator

Uwagi

Przykład

const_pointer

Uwagi

const_reference

Uwagi

Przykład

const_reverse_iterator

Uwagi

Przykład

crbegin

Wartość zwracana

Uwagi

Przykład

crend

Wartość zwracana

Uwagi

Przykład

data

Wartość zwracana

Przykład

difference_type

Uwagi

Przykład

emplace

Parametry

Wartość zwracana

Uwagi

Przykład

emplace_back

Parametry

Przykład

empty

Wartość zwracana

Przykład

end

Wartość zwracana

Uwagi

Klasa `vector`

`allocator_type`

`assign`

`at`

`back`

`begin`

`capacity`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`crbegin`

`crend`

`data`

`difference_type`

`emplace`

`emplace_back`

`empty`

`end`

`erase`

`front`

`get_allocator`

`insert`

`iterator`

`max_size`

`operator[]`

`operator=`

`pointer`

`pop_back`

`push_back`

`rbegin`

`reference`

`rend`

`reserve`

`resize`

`reverse_iterator`

`shrink_to_fit`

`size`

`size_type`

`swap`