vector 类

C++ 标准库向量类是序列容器的类模板。 向量以线性排列方式存储给定类型的元素，并允许快速随机访问任何元素。 向量是需要力求保证访问性能时的首选序列容器。

语法

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

参数

Type
要存储在矢量中的元素数据类型

Allocator
表示所存储分配器对象的类型，该分配器对象封装有关矢量的内存分配和解除分配的详细信息。 此参数为可选参数，默认值为 allocator<Type>。

注解

向量允许在序列末尾插入和删除常量事件。 若要在矢量中间插入或删除元素，则需要线性时间。 deque 类容器在序列开头和末尾的插入和删除速度更快。 list 类容器在序列中任何位置的插入和删除速度更快。

当成员函数必须将矢量对象中所含序列增加到超过其当前存储容量时，将进行矢量重新分配。 其他的插入和删除均可能改变序列中的各个存储地址。 在所有此类情况下，指向序列更改部分的迭代器或引用将变为无效。 如果未进行重新分配，则只有插入/删除点前的迭代器和引用保持有效。

vector<bool> 类是 bool 类型的元素的类模板向量的完全专用化。 它具有专用化使用的基础类型的分配器。

vector<bool> 引用类是一个嵌套类，其对象可以提供对 vector<bool> 对象内的元素（单一位）的引用。

成员

构造函数

名称	描述
vector	构造一个向量，它具有特定大小、具有特定值的元素、具有特定 allocator，或将其构造成某个其它向量的副本。

Typedef

名称	描述
[allocator_type](#allocator_type)	一个类型，它表示矢量对象的 allocator 类。
const_iterator	一个类型，它提供可读取矢量中 const 元素的随机访问迭代器。
const_pointer	一个类型，它提供指向矢量中 const 元素的指针。
const_reference	一个类型，它提供对向量中存储的 const 元素的引用。 它用于读取和执行 const 操作。
const_reverse_iterator	一个类型，它提供可读取矢量中任何 const 元素的随机访问迭代器。
difference_type	一个类型，它提供矢量中两个元素的址间的差异。
iterator	一个类型，它提供可读取或修改向量中任何元素的随机访问迭代器。
pointer	一个类型，提供指向向量中元素的指针。
reference	一个类型，它提供对向量中存储的元素的引用。
reverse_iterator	一个类型，它提供可读取或修改反向矢量中的任意元素的随机访问迭代器。
size_type	一个类型，它计算矢量中的元素数目。
value_type	一个类型，它代表向量中存储的数据类型。

函数

名称	描述
assign	清除矢量并将指定的元素复制到该空矢量。
at	返回对矢量中指定位置的元素的引用。
back	返回对向量中最后一个元素的引用。
begin	对该向量中第一个元素返回随机访问迭代器。
capacity	返回在不分配更多的存储的情况下向量可以包含的元素数。
cbegin	返回指向向量中第一个元素的随机访问常量迭代器。
cend	返回一个随机访问常量迭代器，它指向刚超过矢量末尾的位置。
crbegin	返回一个指向反向矢量中第一个元素的常量迭代器。
crend	返回一个指向反向矢量末尾的常量迭代器。
clear	清除向量的元素。
data	返回指向向量中第一个元素的指针。
emplace	将就地构造的元素插入到指定位置的向量中。
emplace_back	将一个就地构造的元素添加到向量末尾。
empty	测试矢量容器是否为空。
end	返回指向矢量末尾的随机访问迭代器。
erase	从指定位置删除向量中的一个元素或一系列元素。
front	返回对向量中第一个元素的引用。
get_allocator	将对象返回到矢量使用的 allocator 类。
insert	将一个元素或多个元素插入到指定位置的向量中。
max_size	返回向量的最大长度。
pop_back	删除矢量末尾处的元素。
push_back	在矢量末尾处添加一个元素。
rbegin	返回指向反向向量中第一个元素的迭代器。
rend	返回一个指向反向矢量末尾的迭代器。
reserve	保留向量对象的最小存储长度。
resize	为矢量指定新的大小。
shrink_to_fit	放弃额外容量。
size	返回向量中的元素数量。
swap	交换两个向量的元素。

运算符

名称	描述
operator[]	返回对指定位置的矢量元素的引用。
operator=	用另一个向量的副本替换该向量中的元素。

allocator_type

一个类型，它代表向量对象的分配器类。

typedef Allocator allocator_type;

注解

allocator_type 是模板参数 Allocator 的同义词。

示例

有关使用 allocator_type 的示例，请参阅 get_allocator 的示例。

assign

清除矢量并将指定的元素复制到该空矢量。

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

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

参数

first
要复制的元素范围内的第一个元素的位置。

last
要复制的元素范围外的第一个元素的位置。

count
要插入到矢量的元素的副本数。

value
插入到向量中的元素的值。

init_list
包含要插入的元素的 initializer_list。

备注

首先，assign 擦除向量中的所有现有元素。 然后，assign 将指定范围内的元素从原始向量插入某个向量中，或者将新的指定值元素的副本插入某个向量。

示例

/ 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

返回对矢量中指定位置的元素的引用。

reference at(size_type position);

const_reference at(size_type position) const;

参数

position
要在矢量中引用的元素的下标或位置编号。

返回值

对自变量中的下标元素的引用。 如果 position 大于向量的大小，则 at 会引发异常。

注解

如果将 at 的返回值分配给 const_reference，则可以修改向量对象。 如果将 at 的返回值分配给 reference，则可以修改矢量对象。

示例

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

返回对向量中最后一个元素的引用。

reference back();

const_reference back() const;

返回值

向量的最后一个元素。 如果向量为空，则返回值不确定。

备注

如果将 back 的返回值分配给 const_reference，则可以修改向量对象。 如果将 back 的返回值分配给 reference，则可以修改矢量对象。

当使用定义为 1 或 2 的 _ITERATOR_DEBUG_LEVEL 进行编译时，如果试图访问空向量中的元素，则将发生运行时错误。 有关详细信息，请参阅检查的迭代器。

示例

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

对该向量中第一个元素返回随机访问迭代器。

const_iterator begin() const;

iterator begin();

返回值

发现 vector 中第一个元素或空 vector 之后的位置的随机访问迭代器。 始终将返回的值与 vector::end 进行比较以确保其有效。

备注

如果将 begin 的返回值分配给 vector::const_iterator，则可以修改 vector 对象。 如果将 begin 的返回值分配给 vector::iterator，则可以修改 vector 对象。

示例

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

返回在不分配更多的存储的情况下向量可以包含的元素数。

size_type capacity() const;

返回值

分配给该向量的当前存储长度。

注解

如果为成员函数 resize 分配了足够的内存，它将更高效。 使用成员函数 reserve 指定分配的内存量。

示例

// 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 迭代器。

const_iterator cbegin() const;

返回值

const 随机访问迭代器，指向范围的第一个元素，或刚超出空范围末尾的位置（对于空范围，cbegin() == cend()）。

备注

由于使用 cbegin 的返回值，因此不能修改范围中的元素。

可以使用此成员函数替代 begin() 成员函数，以保证返回值为 const_iterator。 它一般与 auto 类型推导关键字一起使用，如以下示例所示。 在此示例中，将 Container 视为支持 begin() 和 cbegin() 的可修改的任何类型的（非- const）容器。

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

// i2 is Container<T>::const_iterator

cend

返回 const 超过末尾迭代器，该迭代器指向向量最后一个元素之后的元素。

const_iterator cend() const;

返回值

向量的 const 超过末尾迭代器。 它指向向量最后一个元素之后的元素。 该元素是一个占位符，不应取消引用。 仅将它用于比较。 如果该向量为空，则返回 vector::cend() == vector::cbegin()。

备注

cend 用于测试迭代器是否超过了其范围的末尾。

可以使用此成员函数替代 end() 成员函数，以保证返回值为 const_iterator。 它一般与 auto 类型推导关键字一起使用，如以下示例所示。 在此示例中，将 Container 视为支持 end() 和 cend() 的可修改的任何类型的（非- const）容器。

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

// i2 is Container<T>::const_iterator

不应对 cend 返回的值取消引用。 仅将它用于比较。

clear

清除向量的元素。

void clear();

示例

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

一个类型，它提供可读取矢量中 const 元素的随机访问迭代器。

typedef implementation-defined const_iterator;

备注

const_iterator 类型不能用于修改元素的值。

示例

有关使用 const_iterator 的示例，请参阅 back 的示例。

const_pointer

一个类型，它提供指向矢量中 const 元素的指针。

typedef typename Allocator::const_pointer const_pointer;

注解

const_pointer 类型不能用于修改元素的值。

iterator 更常用于访问矢量元素。

const_reference

一个类型，它提供对向量中存储的 const 元素的引用。 它用于读取和执行 const 操作。

typedef typename Allocator::const_reference const_reference;

备注

const_reference 类型不能用于修改元素的值。

示例

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

一个类型，它提供可读取矢量中任何 const 元素的随机访问迭代器。

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

注解

const_reverse_iterator 类型无法修改元素的值，它用于反向循环访问向量。

示例

有关如何声明和使用迭代器的示例，请参阅 rbegin。

crbegin

返回一个指向反向矢量中第一个元素的常量迭代器。

const_reverse_iterator crbegin() const;

返回值

发现反向 vector 中的第一个元素或发现曾是非反向 vector 中的最后一个元素的常量反向随机访问迭代器。

注解

返回值为 crbegin 时，无法修改 vector 对象。

示例

// 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 超过末尾反向迭代器，该迭代器指向反向向量最后一个元素之后的元素。

const_reverse_iterator crend() const;

返回值

反向向量的 const 反向超过末尾迭代器。 它指向反向向量最后一个元素之后的元素，该元素与非反向向量第一个元素之前的元素相同。 该元素是一个占位符，不应取消引用。 仅将它用于比较。

备注

crend 用于反向 vector，正如 vector::cend 用于 vector 一样。

由于使用 crend 的返回值（适当递减），因此不能修改 vector 对象。

crend 可用于测试反向迭代器是否已到达其 vector 的末尾。

不应对 crend 返回的值取消引用。 仅将它用于比较。

示例

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

返回指向向量中第一个元素的指针。

const_pointer data() const;

pointer data();

返回值

一个指针，它指向 vector 中第一个元素或紧随空 vector 后的位置。

示例

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

一个类型，它提供引用同一向量中元素的两个迭代器之间的差异。

typedef typename Allocator::difference_type difference_type;

备注

difference_type 也可以被描述为两个指针之间的元素数，因为指向一个元素的指针包含其地址。

iterator 更常用于访问矢量元素。

示例

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

将就地构造的元素插入到指定位置的向量中。

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

参数

position
vector 中插入第一个元素的位置。

args
构造函数参数。 函数根据所提供的自变量来推断要调用的构造函数重载。

返回值

该函数将返回一个指向 vector 中新元素的插入位置的迭代器。

备注

任何插入操作都可能产生巨额开销，请参阅 vector 类，了解有关 vector 性能的讨论。

示例

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

将一个就地构造的元素添加到向量末尾。

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

参数

args
构造函数参数。 函数根据所提供的自变量来推断要调用的构造函数重载。

示例

#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

测试矢量是否为空。

bool empty() const;

返回值

如果向量为空，则返回 true；如果向量不为空，则返回 false。

示例

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

返回超过末尾迭代器，该迭代器指向向量最后一个元素之后的元素。

iterator end();

const_iterator end() const;

返回值

向量的超过末尾迭代器。 它指向向量最后一个元素之后的元素。 该元素是一个占位符，不应取消引用。 仅将它用于比较。 如果该向量为空，则返回 vector::end() == vector::begin()。

备注

如果将 end 的返回值分配给 const_iterator 类型的变量，则无法修改向量对象。 如果将 end 的返回值分配给 iterator 类型的变量，则可以修改向量对象。

示例

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

从指定位置删除向量中的一个元素或一系列元素。

iterator erase(
    const_iterator position);

iterator erase(
    const_iterator first,
    const_iterator last);

参数

position
要从向量中移除的元素的位置。

first
要从向量中移除的第一个元素的位置。

last
紧接要从向量中移除的最后一个元素的位置。

返回值

一个迭代器，它指定已移除的任何元素之外保留的第一个元素或指向向量末尾的指针（若此类元素不存在）。

示例

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

返回对向量中第一个元素的引用。

reference front();

const_reference front() const;

返回值

对向量对象中第一个元素的引用。 如果向量为空，则返回值不确定。

备注

如果将 front 的返回值分配给 const_reference，则可以修改向量对象。 如果将 front 的返回值分配给 reference，则可以修改矢量对象。

当使用定义为 1 或 2 的 _ITERATOR_DEBUG_LEVEL 进行编译时，如果试图访问空向量中的元素，则将发生运行时错误。 有关详细信息，请参阅检查的迭代器。

示例

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

返回用于构造矢量的分配器对象的一个副本。

Allocator get_allocator() const;

返回值

向量所使用的分配器。

备注

矢量类的分配器指定类管理存储的方式。 C++ 标准库容器类提供的默认分配器足以满足大多编程需求。 编写和使用你自己的分配器类是高级 C++ 功能。

示例

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

将一个、多个或一系列元素插入到指定位置的向量中。

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

参数

position
向量中插入第一个元素的位置。

value
插入到向量中的元素的值。

count
插入向量中的元素数目。

first
要复制的范围元素中的第一个元素的位置。

last
要复制的元素范围以外的第一个元素的位置。

返回值

前两个 insert 函数返回一个指定新元素插入到向量的位置的迭代器。

备注

前提是，first 和 last 一定不能是矢量中的迭代器，或行为不可确定。 任何插入操作都可能产生巨额开销，请参阅 vector 类，了解有关 vector 性能的讨论。

示例

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

一个类型，它提供可读取或修改向量中任何元素的随机访问迭代器。

typedef implementation-defined iterator;

注解

iterator 类型可用于修改元素的值。

示例

请参阅 begin 的示例。

max_size

返回向量的最大长度。

size_type max_size() const;

返回值

向量的最大可取长度。

示例

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

返回对指定位置的矢量元素的引用。

reference operator[](size_type position);

const_reference operator[](size_type position) const;

参数

position
矢量元素的位置。

返回值

如果指定的位置大于或等于容器大小，则结果为 undefined。

注解

如果将 operator[] 的返回值分配给 const_reference，则可以修改向量对象。 如果将 operator[] 的返回值分配给引用，则可以修改矢量对象。

当使用定义为 1 或 2 的 _ITERATOR_DEBUG_LEVEL 进行编译时，如果试图访问向量边界之外的元素，将发生运行时错误。 有关详细信息，请参阅检查的迭代器。

示例

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

用另一个向量的副本替换该向量中的元素。

vector& operator=(const vector& right);

vector& operator=(vector&& right);

参数

right
要复制到 vector 中的 vector。

备注

清除 vector 中的任何现有元素后，operator= 会将 right 的内容复制或移动到 vector。

示例

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

一个类型，提供指向向量中元素的指针。

typedef typename Allocator::pointer pointer;

备注

pointer 类型可用于修改元素的值。

示例

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

删除矢量末尾处的元素。

void pop_back();

备注

有关代码示例，请参阅 vector::push_back()。

push_back

在矢量末尾处添加一个元素。

void push_back(const T& value);

void push_back(T&& value);

参数

value
要赋给添加到矢量末尾处的元素的值。

示例

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

返回指向反向向量中第一个元素的迭代器。

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

返回值

发现反向矢量中的第一个元素或发现曾是非反向矢量中的最后一个元素的反向双向迭代器。

备注

如果将 rbegin 的返回值分配给 const_reverse_iterator，则可以修改向量对象。 如果将 rbegin 的返回值分配给 reverse_iterator，则可以修改矢量对象。

示例

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

一个类型，它提供对向量中存储的元素的引用。

typedef typename Allocator::reference reference;

示例

有关如何在向量类中使用 reference 的示例，请参阅 at。

rend

返回超过末尾反向迭代器，该迭代器指向反向向量最后一个元素之后的元素。

const_reverse_iterator rend() const;
reverse_iterator rend();

返回值

反向向量的反向超过末尾迭代器。 它指向反向向量最后一个元素之后的元素，该元素与非反向向量第一个元素之前的元素相同。 该元素是一个占位符，不应取消引用。 仅将它用于比较。

备注

rend 用于反向向量，正如 end 用于向量一样。

如果将 rend 的返回值分配给 const_reverse_iterator，则无法修改向量对象。 如果将 rend 的返回值分配给 reverse_iterator，则可以修改矢量对象。

rend 可用于测试反向迭代器是否已到达其矢量末尾。

不应对 rend 返回的值取消引用。 仅将它用于比较。

示例

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

为向量对象保留最小的存储长度，必要时为其分配空间。

void reserve(size_type count);

参数

count
要分配给向量的最小存储长度。

示例

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

为矢量指定新的大小。

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

参数

new_size
矢量的新大小。

value
新大小大于旧大小时添加至矢量的新元素的初始化值。 如果省略该值，则新对象将使用其默认构造函数。

注解

如果容器的大小小于请求的大小 new_size，则 resize 会在向量中添加元素，直到该容器达到请求的大小。 如果容器的大小大于请求的大小，则 resize 会删除最接近容器末尾的元素，直到该容器达到大小 new_size。 如果容器的当前大小与请求的大小相同，则不采取任何操作。

size 表示向量的当前大小。

示例

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

一个类型，它提供可读取或修改反向矢量中的任意元素的随机访问迭代器。

typedef std::reverse_iterator<iterator> reverse_iterator;

备注

reverse_iterator 类型用于反向循环访问向量。

示例

请参阅 rbegin 的示例。

shrink_to_fit

放弃额外容量。

void shrink_to_fit();

示例

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

返回向量中的元素数量。

size_type size() const;

返回值

向量的当前长度。

示例

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

一个类型，它计算矢量中的元素数目。

typedef typename Allocator::size_type size_type;

示例

请参阅 capacity 的示例。

swap

交换两个向量的元素。

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

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

参数

right
一个提供要交换的元素的向量。 或者一个其元素将与向量 left 中的元素进行交换的向量。

left
一个其元素将与向量 right 中的元素进行交换的向量。

示例

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

一个类型，它代表向量中存储的数据类型。

typedef typename Allocator::value_type value_type;

备注

value_type 是模板参数 Type 的同义词。

示例

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

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

44

vector

构造向量。 重载构造一个特定大小的向量，或具有特定值的元素的向量。 或者，作为其他某个向量的整体或一部分的副本。 某些重载还允许指定要使用的分配器。

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

参数

allocator
要用于此对象的分配器类。 get_allocator 返回对象的分配器类。

count
构造的矢量中的元素数。

value
构造的矢量中的元素值。

source
要成为副本的构造的矢量中的矢量。

first
要复制的元素范围内的第一个元素的位置。

last
要复制的元素范围外的第一个元素的位置。

init_list
包含要复制的元素的 initializer_list。

备注

所有构造函数都存储分配器对象 (allocator) 并初始化此向量。

前两个构造函数指定一个空初始矢量。 第二个构造函数显式指定要使用的分配器类型 (allocator)。

第三个构造函数指定类 count 的默认值的指定数量 (Type) 的元素的重复。

第四个和第五个构造函数指定值为 value 的 (count) 个元素的重复元素。

第六个构造函数指定矢量 source 的副本。

第七个构造函数移动矢量 source。

第八个构造函数使用 initializer_list 指定元素。

第九个和第十个构造函数复制矢量的范围（first、last）。

示例

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

另请参阅

C++ 标准库中的线程安全
C++ 标准库参考