`vector` classe

Artigo
03/11/2025

A classe vetorial C++ Standard Library é um modelo de classe para contêineres de sequência. Um vetor armazena elementos de um determinado tipo em um arranjo linear e permite acesso aleatório rápido a qualquer elemento. Um vetor é o recipiente preferido para uma sequência quando o desempenho de acesso aleatório é um prêmio.

Sintaxe

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

Parâmetros

Type
O tipo de dados do elemento a ser armazenado no vetor.

Allocator
O tipo que representa o objeto de alocador armazenado que encapsula detalhes sobre a alocação e desalocação de memória do vetor. Esse argumento é opcional e o valor padrão é allocator<Type>.

Comentários

Os vetores permitem inserções e exclusões de tempo constante no final da sequência. Inserir ou excluir elementos no meio de um vetor requer tempo linear. O contêiner classedeque é mais rápido em inserções e exclusões no início e no final de uma sequência. O contêiner classelist é mais rápido em inserções e exclusões em qualquer local dentro de uma sequência.

A realocação vetorial ocorre quando uma função membro deve aumentar a sequência contida no objeto vetorial além de sua capacidade de armazenamento atual. Outras inserções e rasuras podem alterar vários endereços de armazenamento dentro da sequência. Em todos esses casos, iteradores ou referências que apontam para partes alteradas da sequência tornam-se inválidos. Se não houver reatribuição, apenas os iteradores e as referências anteriores ao ponto de inserção/eliminação permanecem válidos.

O de classevector<bool> é uma especialização completa do vetor de modelo de classe para elementos do tipo bool. Tem um alocador para o tipo subjacente usado pela especialização.

A classe de referência vector<bool> é uma classe aninhada cujos objetos podem fornecer referências a elementos (bits únicos) dentro de um objeto vector<bool>.

Membros

Construtores

Designação	Descrição
`vector`	Constrói um vetor de um tamanho específico ou com elementos de um valor específico ou com um `allocator` específico ou como uma cópia de algum outro vetor.

Typedefs

Designação	Descrição
`allocator_type`	Um tipo que representa a classe `allocator` para o objeto vetorial.
`const_iterator`	Um tipo que fornece um iterador de acesso aleatório que pode ler um elemento `const` em um vetor.
`const_pointer`	Um tipo que fornece um ponteiro para um elemento `const` em um vetor.
`const_reference`	Um tipo que fornece uma referência a um elemento `const` armazenado em um vetor. É usado para ler e fazer `const` operações.
`const_reverse_iterator`	Um tipo que fornece um iterador de acesso aleatório que pode ler qualquer elemento `const` no vetor.
`difference_type`	Um tipo que fornece a diferença entre os endereços de dois elementos em um vetor.
`iterator`	Um tipo que fornece um iterador de acesso aleatório que pode ler ou modificar qualquer elemento em um vetor.
`pointer`	Um tipo que fornece um ponteiro para um elemento em um vetor.
`reference`	Um tipo que fornece uma referência a um elemento armazenado em um vetor.
`reverse_iterator`	Um tipo que fornece um iterador de acesso aleatório que pode ler ou modificar qualquer elemento em um vetor invertido.
`size_type`	Um tipo que conta o número de elementos em um vetor.
`value_type`	Um tipo que representa o tipo de dados armazenados em um vetor.

Funções

Designação	Descrição
`assign`	Apaga um vetor e copia os elementos especificados para o vetor vazio.
`at`	Retorna uma referência ao elemento em um local especificado no vetor.
`back`	Retorna uma referência ao último elemento do vetor.
`begin`	Retorna um iterador de acesso aleatório para o primeiro elemento no vetor.
`capacity`	Retorna o número de elementos que o vetor poderia conter sem alocar mais armazenamento.
`cbegin`	Retorna um iterador const de acesso aleatório para o primeiro elemento no vetor.
`cend`	Retorna um iterador const de acesso aleatório que aponta logo além do final do vetor.
`crbegin`	Retorna um iterador const para o primeiro elemento em um vetor invertido.
`crend`	Retorna um iterador const para o final de um vetor invertido.
`clear`	Apaga os elementos do vetor.
`data`	Retorna um ponteiro para o primeiro elemento no vetor.
`emplace`	Insere um elemento construído no lugar no vetor em uma posição especificada.
`emplace_back`	Adiciona um elemento construído no lugar ao final do vetor.
`empty`	Testa se o recipiente vetorial está vazio.
`end`	Retorna um iterador de acesso aleatório que aponta para o final do vetor.
`erase`	Remove um elemento ou um intervalo de elementos em um vetor de posições especificadas.
`front`	Retorna uma referência ao primeiro elemento em um vetor.
`get_allocator`	Retorna um objeto para a classe `allocator` usada por um vetor.
`insert`	Insere um elemento ou muitos elementos no vetor em uma posição especificada.
`max_size`	Retorna o comprimento máximo do vetor.
`pop_back`	Exclui o elemento no final do vetor.
`push_back`	Adicione um elemento ao final do vetor.
`rbegin`	Retorna um iterador para o primeiro elemento em um vetor invertido.
`rend`	Retorna um iterador ao final de um vetor invertido.
`reserve`	Reserva um comprimento mínimo de armazenamento para um objeto vetorial.
`resize`	Especifica um novo tamanho para um vetor.
`shrink_to_fit`	Elimina o excesso de capacidade.
`size`	Retorna o número de elementos no vetor.
`swap`	Troca os elementos de dois vetores.

Operadores

Designação	Descrição
`operator[]`	Retorna uma referência ao elemento vetorial em uma posição especificada.
`operator=`	Substitui os elementos do vetor por uma cópia de outro vetor.

`allocator_type`

Um tipo que representa a classe alocator para o objeto vetorial.

typedef Allocator allocator_type;

Comentários

allocator_type é sinônimo do parâmetro de modelo Allocator.

Exemplo

Veja o exemplo para get_allocator para um exemplo que usa allocator_type.

`assign`

Apaga um vetor e copia os elementos especificados para o vetor vazio.

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

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

Parâmetros

first
Posição do primeiro elemento na gama de elementos a copiar.

last
Posição do primeiro elemento para além da gama de elementos a copiar.

count
O número de cópias de um elemento que está sendo inserido no vetor.

value
O valor do elemento que está sendo inserido no vetor.

init_list
O initializer_list que contém os elementos a inserir.

Comentários

Primeiro, assign apaga todos os elementos existentes em um vetor. Em seguida, assign insere um intervalo especificado de elementos do vetor original em um vetor ou insere cópias de um novo elemento de valor especificado em um vetor.

Exemplo

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

Retorna uma referência ao elemento em um local especificado no vetor.

reference at(size_type position);

const_reference at(size_type position) const;

Parâmetros

position
O subscrito ou o número da posição do elemento a ser referenciado no vetor.

Valor de retorno

Uma referência ao elemento subscrito no argumento. Se position for maior do que o tamanho do vetor, at lançará uma exceção.

Comentários

Se o valor de retorno de at for atribuído a um const_reference, o objeto vetorial não poderá ser modificado. Se o valor de retorno de at for atribuído a um reference, o objeto vetorial poderá ser modificado.

Exemplo

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

Retorna uma referência ao último elemento do vetor.

reference back();

const_reference back() const;

Valor de retorno

O último elemento do vetor. Se o vetor estiver vazio, o valor de retorno será indefinido.

Comentários

Se o valor de retorno de back for atribuído a um const_reference, o objeto vetorial não poderá ser modificado. Se o valor de retorno de back for atribuído a um reference, o objeto vetorial poderá ser modificado.

Quando compilado usando _ITERATOR_DEBUG_LEVEL definido como 1 ou 2, ocorre um erro de tempo de execução se você tentar acessar um elemento em um vetor vazio. Para obter mais informações, consulte Iteradores verificados.

Exemplo

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

Retorna um iterador de acesso aleatório para o primeiro elemento no vetor.

const_iterator begin() const;

iterator begin();

Valor de retorno

Um iterador de acesso aleatório endereçando o primeiro elemento no vector ou para o local que sucede um vectorvazio . Sempre compare o valor retornado com vector::end para garantir que ele seja válido.

Comentários

Se o valor de retorno de begin for atribuído a um vector::const_iterator, o objeto vector não poderá ser modificado. Se o valor de retorno de begin for atribuído a um vector::iterator, o objeto vector poderá ser modificado.

Exemplo

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

Retorna o número de elementos que o vetor poderia conter sem alocar mais armazenamento.

size_type capacity() const;

Valor de retorno

O comprimento atual de armazenamento alocado para o vetor.

Comentários

A função de membro resize será mais eficiente se houver memória suficiente para acomodá-la. Use a função de membro reserve para especificar a quantidade de memória alocada.

Exemplo

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

Retorna um iterador const que aborda o primeiro elemento no intervalo.

const_iterator cbegin() const;

Valor de retorno

Um iterador de acesso aleatório const que aponta para o primeiro elemento do intervalo ou para o local logo após o final de um intervalo vazio (para um intervalo vazio, cbegin() == cend()).

Comentários

Com o valor de retorno de cbegin, os elementos no intervalo não podem ser modificados.

Você pode usar essa função de membro no lugar da função de membro begin() para garantir que o valor de retorno seja const_iterator. Normalmente, ele é usado com a palavra-chave de dedução de tipo auto, conforme mostrado no exemplo a seguir. No exemplo, considere Container como um recipiente modificável (não const) de qualquer tipo que suporte begin() e cbegin().

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

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

`cend`

Retorna um const iterador passado-a-fim que aponta para o elemento que segue o último elemento do vetor.

const_iterator cend() const;

Valor de retorno

Um const iterador passado a fim para o vetor. Ele aponta para o elemento que segue o último elemento do vetor. Esse elemento é um espaço reservado e não deve ser desreferenciado. Use-o apenas para comparações. Se o vetor estiver vazio, então vector::cend() == vector::cbegin().

Comentários

cend é usado para testar se um iterador passou no final de seu intervalo.

Você pode usar essa função de membro no lugar da função de membro end() para garantir que o valor de retorno seja const_iterator. Normalmente, ele é usado com a palavra-chave de dedução de tipo auto, conforme mostrado no exemplo a seguir. No exemplo, considere Container como um recipiente modificável (não const) de qualquer tipo que suporte end() e cend().

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

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

O valor retornado por cend não deve ser desreferenciado. Use-o apenas para comparações.

`clear`

Apaga os elementos do vetor.

void clear();

Exemplo

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

Um tipo que fornece um iterador de acesso aleatório que pode ler um elemento const em um vetor.

typedef implementation-defined const_iterator;

Comentários

Um tipo const_iterator não pode ser usado para modificar o valor de um elemento.

Exemplo

Consulte o exemplo para de volta para um exemplo que usa const_iterator.

`const_pointer`

Um tipo que fornece um ponteiro para um elemento const em um vetor.

typedef typename Allocator::const_pointer const_pointer;

Comentários

Um tipo const_pointer não pode ser usado para modificar o valor de um elemento.

Um iterador de é mais comumente usado para acessar um elemento vetorial.

`const_reference`

Um tipo que fornece uma referência a um elemento const armazenado em um vetor. É usado para ler e fazer const operações.

typedef typename Allocator::const_reference const_reference;

Comentários

Um tipo const_reference não pode ser usado para modificar o valor de um elemento.

Exemplo

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

Um tipo que fornece um iterador de acesso aleatório que pode ler qualquer elemento const no vetor.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Comentários

Um tipo const_reverse_iterator não pode modificar o valor de um elemento e é usado para iterar através do vetor em sentido inverso.

Exemplo

Consulte rbegin para obter um exemplo de como declarar e usar um iterador.

`crbegin`

Retorna um iterador const para o primeiro elemento em um vetor invertido.

const_reverse_iterator crbegin() const;

Valor de retorno

Um iterador de acesso aleatório reverso const abordando o primeiro elemento em uma vector invertida ou abordando o que havia sido o último elemento na vectornão invertida.

Comentários

Com o valor de retorno de crbegin, o objeto vector não pode ser modificado.

Exemplo

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

Retorna um const iterador reverso passado a fim que aponta para o elemento que segue o último elemento do vetor invertido.

const_reverse_iterator crend() const;

Valor de retorno

Um const iterador passado a fim reverso para o vetor invertido. Ele aponta para o elemento que segue o último elemento do vetor invertido, que é o mesmo que o elemento antes do primeiro elemento do vetor não invertido. Esse elemento é um espaço reservado e não deve ser desreferenciado. Use-o apenas para comparações.

Comentários

crend é usado com um vector invertido, assim como vector::cend é usado com um vector.

Com o valor de retorno de crend (adequadamente diminuído), o objeto vector não pode ser modificado.

crend pode ser usado para testar se um iterador reverso chegou ao final de sua vector.

O valor retornado por crend não deve ser desreferenciado. Use-o apenas para comparações.

Exemplo

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

Retorna um ponteiro para o primeiro elemento no vetor.

const_pointer data() const;

pointer data();

Valor de retorno

Um ponteiro para o primeiro elemento no vector ou para o local que sucede a um vectorvazio.

Exemplo

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

Um tipo que fornece a diferença entre dois iteradores que se referem a elementos dentro do mesmo vetor.

typedef typename Allocator::difference_type difference_type;

Comentários

Um difference_type também pode ser descrito como o número de elementos entre dois ponteiros, porque um ponteiro para um elemento contém seu endereço.

Um iterador de é mais comumente usado para acessar um elemento vetorial.

Exemplo

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

Insere um elemento construído no lugar no vetor em uma posição especificada.

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

Parâmetros

position
A posição no vector onde o primeiro elemento é inserido.

args
Argumentos do construtor. A função infere qual sobrecarga do construtor invocar com base nos argumentos fornecidos.

Valor de retorno

A função retorna um iterador que aponta para a posição onde o novo elemento foi inserido no vector.

Comentários

Qualquer operação de inserção pode ser cara, consulte vector de classe para uma discussão sobre vector desempenho.

Exemplo

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

Adiciona um elemento construído no lugar ao final do vetor.

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

Parâmetros

args
Argumentos do construtor. A função infere qual sobrecarga do construtor invocar com base nos argumentos fornecidos.

Exemplo

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

Testa se o vetor está vazio.

bool empty() const;

Valor de retorno

true se o vetor estiver vazio; false se o vetor não estiver vazio.

Exemplo

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

Retorna um iterador passado-a-fim que aponta para o elemento que segue o último elemento do vetor.

iterator end();

const_iterator end() const;

Valor de retorno

Um iterador passado-a-fim para o vetor. Ele aponta para o elemento que segue o último elemento do vetor. Esse elemento é um espaço reservado e não deve ser desreferenciado. Use-o apenas para comparações. Se o vetor estiver vazio, então vector::end() == vector::begin().

Comentários

Se o valor de retorno de end for atribuído a uma variável do tipo const_iterator, o objeto vetorial não poderá ser modificado. Se o valor de retorno de end for atribuído a uma variável do tipo iterator, o objeto vetorial poderá ser modificado.

Exemplo

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

Remove um elemento ou um intervalo de elementos em um vetor de posições especificadas.

iterator erase(
    const_iterator position);

iterator erase(
    const_iterator first,
    const_iterator last);

Parâmetros

position
Posição do elemento a ser removido do vetor.

first
Posição do primeiro elemento removido do vetor.

last
Posicione logo após o último elemento removido do vetor.

Valor de retorno

Um iterador que designa o primeiro elemento restante além de quaisquer elementos removidos, ou um ponteiro para o final do vetor, se tal elemento não existir.

Exemplo

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

Retorna uma referência ao primeiro elemento em um vetor.

reference front();

const_reference front() const;

Valor de retorno

Uma referência ao primeiro elemento no objeto vetorial. Se o vetor estiver vazio, o retorno será indefinido.

Comentários

Se o valor de retorno de front for atribuído a um const_reference, o objeto vetorial não poderá ser modificado. Se o valor de retorno de front for atribuído a um reference, o objeto vetorial poderá ser modificado.

Exemplo

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

Retorna uma cópia do objeto alocador usado para construir o vetor.

Allocator get_allocator() const;

Valor de retorno

O alocador usado pelo vetor.

Comentários

Os alocadores para a classe vetor especificam como a classe gerencia o armazenamento. Os alocadores padrão fornecidos com classes de contêiner C++ Standard Library são suficientes para a maioria das necessidades de programação. Escrever e usar sua própria classe de alocador é um recurso avançado de C++.

Exemplo

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

Insere um elemento, ou muitos elementos, ou um intervalo de elementos no vetor em uma posição especificada.

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

Parâmetros

position
A posição no vetor onde o primeiro elemento é inserido.

value
O valor do elemento que está sendo inserido no vetor.

count
O número de elementos que estão sendo inseridos no vetor.

first
A posição do primeiro elemento na gama de elementos a serem copiados.

last
A posição do primeiro elemento além da gama de elementos a serem copiados.

Valor de retorno

As duas primeiras funções insert retornam um iterador que aponta para a posição onde o novo elemento foi inserido no vetor.

Comentários

Como pré-condição, first e last não devem ser iteradores no vetor, ou o comportamento é indefinido. Qualquer operação de inserção pode ser cara, consulte vector de classe para uma discussão sobre vector desempenho.

Exemplo

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

Um tipo que fornece um iterador de acesso aleatório que pode ler ou modificar qualquer elemento em um vetor.

typedef implementation-defined iterator;

Comentários

Um tipo iterator pode ser usado para modificar o valor de um elemento.

Exemplo

Veja o exemplo para begin.

`max_size`

Retorna o comprimento máximo do vetor.

size_type max_size() const;

Valor de retorno

O comprimento máximo possível do vetor.

Exemplo

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

Retorna uma referência ao elemento vetorial em uma posição especificada.

reference operator[](size_type position);

const_reference operator[](size_type position) const;

Parâmetros

position
A posição do elemento vetorial.

Valor de retorno

Se a posição especificada for maior ou igual ao tamanho do recipiente, o resultado será indefinido.

Comentários

Se o valor de retorno de operator[] for atribuído a um const_reference, o objeto vetorial não poderá ser modificado. Se o valor de retorno de operator[] for atribuído a uma referência, o objeto vetorial poderá ser modificado.

Quando compilado usando _ITERATOR_DEBUG_LEVEL definido como 1 ou 2, ocorre um erro de tempo de execução se você tentar acessar um elemento fora dos limites do vetor. Para obter mais informações, consulte Iteradores verificados.

Exemplo

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

Substitui os elementos do vetor por uma cópia de outro vetor.

vector& operator=(const vector& right);

vector& operator=(vector&& right);

Parâmetros

right
O vector sendo copiado para o vector.

Comentários

Depois de apagar quaisquer elementos existentes em um vector, operator= copia ou move o conteúdo de right para o vector.

Exemplo

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

Um tipo que fornece um ponteiro para um elemento em um vetor.

typedef typename Allocator::pointer pointer;

Comentários

Um tipo pointer pode ser usado para modificar o valor de um elemento.

Exemplo

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

Exclui o elemento no final do vetor.

void pop_back();

Comentários

Para obter um exemplo de código, consulte vetor::p ush_back().

`push_back`

Adiciona um elemento ao final do vetor.

void push_back(const T& value);

void push_back(T&& value);

Parâmetros

value
O valor a ser atribuído ao elemento adicionado ao final do vetor.

Exemplo

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

Retorna um iterador para o primeiro elemento em um vetor invertido.

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

Valor de retorno

Um iterador de acesso aleatório reverso abordando o primeiro elemento em um vetor reverso ou abordando o que havia sido o último elemento no vetor não invertido.

Comentários

Se o valor de retorno de rbegin for atribuído a um const_reverse_iterator, o objeto vetorial não poderá ser modificado. Se o valor de retorno de rbegin for atribuído a um reverse_iterator, o objeto vetorial poderá ser modificado.

Exemplo

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

Um tipo que fornece uma referência a um elemento armazenado em um vetor.

typedef typename Allocator::reference reference;

Exemplo

Consulte at para obter um exemplo de como usar reference na classe vetor.

`rend`

Retorna um iterador reverso passado a fim que aponta para o elemento que segue o último elemento do vetor invertido.

const_reverse_iterator rend() const;
reverse_iterator rend();

Valor de retorno

Um iterador passado e final reverso para o vetor invertido. Ele aponta para o elemento que segue o último elemento do vetor invertido, que é o mesmo que o elemento antes do primeiro elemento do vetor não invertido. Esse elemento é um espaço reservado e não deve ser desreferenciado. Use-o apenas para comparações.

Comentários

rend é usado com um vetor reverso, assim como end é usado com um vetor.

Se o valor de retorno de rend for atribuído a um const_reverse_iterator, o objeto vetorial não poderá ser modificado. Se o valor de retorno de rend for atribuído a um reverse_iterator, o objeto vetorial poderá ser modificado.

rend pode ser usado para testar se um iterador reverso atingiu o final de seu vetor.

O valor retornado por rend não deve ser desreferenciado. Use-o apenas para comparações.

Exemplo

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

Reserva um comprimento mínimo de armazenamento para um objeto vetorial, alocando espaço se necessário.

void reserve(size_type count);

Parâmetros

count
O comprimento mínimo de armazenamento a ser alocado para o vetor.

Exemplo

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

Especifica um novo tamanho para um vetor.

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

Parâmetros

new_size
O novo tamanho do vetor.

value
O valor de inicialização de novos elementos adicionados ao vetor se o novo tamanho for maior que o tamanho original. Se o valor for omitido, os novos objetos usarão seu construtor padrão.

Comentários

Se o tamanho do contêiner for menor que o tamanho solicitado, new_size, resize adicionará elementos ao vetor até que ele atinja o tamanho solicitado. Quando o tamanho do contêiner é maior do que o tamanho solicitado, o resize exclui os elementos mais próximos do final do contêiner até que ele atinja o tamanho new_size. Nenhuma ação será tomada se o tamanho atual do contêiner for o mesmo que o tamanho solicitado.

size reflete o tamanho atual do vetor.

Exemplo

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

Um tipo que fornece um iterador de acesso aleatório que pode ler ou modificar qualquer elemento em um vetor invertido.

typedef std::reverse_iterator<iterator> reverse_iterator;

Comentários

Um tipo reverse_iterator é usado para iterar através do vetor em sentido inverso.

Exemplo

Veja o exemplo para rbegin.

`shrink_to_fit`

Elimina o excesso de capacidade.

void shrink_to_fit();

Exemplo

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

Retorna o número de elementos no vetor.

size_type size() const;

Valor de retorno

O comprimento atual do vetor.

Exemplo

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

Um tipo que conta o número de elementos em um vetor.

typedef typename Allocator::size_type size_type;

Exemplo

Veja o exemplo para capacity.

`swap`

Troca os elementos de dois vetores.

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

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

Parâmetros

right
Um vetor que fornece os elementos a serem trocados. Ou, um vetor cujos elementos devem ser trocados com os elementos no vetor left.

left
Um vetor cujos elementos devem ser trocados com os elementos no vetor right.

Exemplo

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

Um tipo que representa o tipo de dados armazenados em um vetor.

typedef typename Allocator::value_type value_type;

Comentários

value_type é sinônimo do parâmetro de modelo Type.

Exemplo

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

Constrói um vetor. As sobrecargas constroem um vetor de um tamanho específico ou com elementos de um valor específico. Ou, como uma cópia de todo ou parte de algum outro vetor. Algumas sobrecargas também permitem especificar o alocador a ser usado.

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

Parâmetros

allocator
A classe de alocador a ser usada com esse objeto. get_allocator retorna a classe alocator para o objeto.

count
O número de elementos no vetor construído.

value
O valor dos elementos no vetor construído.

source
O vetor do qual o vetor construído deve ser uma cópia.

first
Posição do primeiro elemento na gama de elementos a copiar.

last
Posição do primeiro elemento para além da gama de elementos a copiar.

init_list
O initializer_list contendo os elementos a serem copiados.

Comentários

Todos os construtores armazenam um objeto alocador (allocator) e inicializam o vetor.

Os dois primeiros construtores especificam um vetor inicial vazio. O segundo construtor especifica explicitamente o tipo de alocador (allocator) a ser usado.

O terceiro construtor especifica uma repetição de um número especificado (count) de elementos do valor padrão para a classe Type.

O quarto e quinto construtores especificam uma repetição de (count) elementos de valor value.

O sexto construtor especifica uma cópia do vetor source.

O sétimo construtor move o vetor source.

O oitavo construtor usa um initializer_list para especificar os elementos.

O nono e décimo construtores copiam o intervalo [first, last) de um vetor.

Exemplo

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

Ver também

segurança de threads na biblioteca padrão C++
de referência da biblioteca padrão C++

Partilhar via

vector classe

Sintaxe

Parâmetros

Comentários

Membros

Construtores

Typedefs

Funções

Operadores

allocator_type

Comentários

Exemplo

assign

Parâmetros

Comentários

Exemplo

at

Parâmetros

Valor de retorno

Comentários

Exemplo

back

Valor de retorno

Comentários

Exemplo

begin

Valor de retorno

Comentários

Exemplo

capacity

Valor de retorno

Comentários

Exemplo

cbegin

Valor de retorno

Comentários

cend

Valor de retorno

Comentários

clear

Exemplo

const_iterator

Comentários

Exemplo

const_pointer

Comentários

const_reference

Comentários

Exemplo

const_reverse_iterator

Comentários

Exemplo

crbegin

Valor de retorno

Comentários

Exemplo

crend

Valor de retorno

Comentários

Exemplo

data

Valor de retorno

Exemplo

difference_type

Comentários

Exemplo

emplace

Parâmetros

Valor de retorno

Comentários

Exemplo

emplace_back

Parâmetros

Exemplo

empty

Valor de retorno

Exemplo

end

Valor de retorno

`vector` classe

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