vector<T, Alloc>


类别：容器	组件类型：类型

描述

一个vector是一个序列，支持对元素的随机访问、在末尾进行常数时间插入和删除元素，以及在开头或中间进行线性时间插入和删除元素。一个vector中的元素数量可以动态变化；内存管理是自动的。Vector是 STL 容器类中最简单的，在很多情况下也是最有效的。

示例

vector<int> V;
V.insert(V.begin(), 3);
assert(V.size() == 1 && V.capacity() >= 1 && V[0] == 3);

定义

定义在标准头文件 vector 中，以及非标准的向后兼容头文件 vector.h 中。

模板参数

参数	描述	默认值
`T`	vector 的值类型：存储在 vector 中的对象类型。
`Alloc`	是`vector`的分配器，用于所有内部内存管理。	`alloc`

模型

随机访问容器，后插入序列。

类型要求

没有，除了随机访问容器和后插入序列要求的以外。

公共基类

无。

成员

成员	定义位置	描述
`value_type`	容器	对象类型，`T`，存储在 vector 中。
`pointer`	容器	指向`T`.
`reference`	容器	对`T`
`const_reference`	容器	对`T`
`size_type`	容器	无符号整型。
`difference_type`	容器	有符号整型。
`iterator`	容器	迭代器，用于遍历一个`vector`.
`const_iterator`	容器	常量迭代器，用于遍历一个`vector`.
`reverse_iterator`	可逆容器	迭代器，用于反向遍历一个`vector`.
`const_reverse_iterator`	可逆容器	常量迭代器，用于反向遍历一个`vector`.
`iterator begin()`	容器	返回一个`iterator`指向 vector 开头的迭代器。`vector`.
`iterator end()`	容器	返回一个`iterator`指向 vector 结尾的迭代器。`vector`.
`const_iterator begin() const`	容器	返回一个`const_iterator`指向 vector 开头的迭代器。`vector`.
`const_iterator end() const`	容器	返回一个`const_iterator`指向 vector 结尾的迭代器。`vector`.
`reverse_iterator rbegin()`	可逆容器	返回一个`reverse_iterator`指向反转 vector 开头的迭代器。
`reverse_iterator rend()`	可逆容器	返回一个`reverse_iterator`指向反转 vector 结尾的迭代器。
`const_reverse_iterator rbegin() const`	可逆容器	返回一个`const_reverse_iterator`指向反转 vector 开头的迭代器。
`const_reverse_iterator rend() const`	可逆容器	返回一个`const_reverse_iterator`指向反转 vector 结尾的迭代器。
`size_type size() const`	容器	返回 vector 的大小。`vector`.
`size_type max_size() const`	容器	返回 vector 的最大可能大小。`vector`.
`size_type capacity() const`	`vector`	见下文。
`bool empty() const`	容器	`如果 vector 的大小是`，则返回 true`vector`。`0`.
`reference operator[](size_type n)`	随机访问容器	返回`n`个元素。
`const_reference operator[](size_type n) const`	随机访问容器	返回`n`个元素。
`vector()`	容器	创建一个空的 vector。
`vector(size_type n)`	序列	创建一个具有`n`个元素的 vector。
`vector(size_type n, const T& t)`	序列	创建一个具有`n`的`t`.
`的副本。`	容器	vector(const vector&)
template <class InputIterator> vector(InputIterator, InputIterator) [1]	序列	复制构造函数。
`创建一个具有一个范围副本的 vector。`	容器	~vector()
`析构函数。`	容器	vector& operator=(const vector&)
`赋值运算符`	`vector`	见下文。
`void reserve(size_t)`	序列	reference front()
`返回第一个元素。`	序列	reference front()
`const_reference front() const`	reference back()	后插入序列
`返回最后一个元素。`	reference back()	后插入序列
`const_reference back() const`	reference back()	void push_back(const T&)
`在末尾插入一个新元素。`	reference back()	void pop_back()
`删除最后一个元素。`	容器	void swap(vector&)
iterator insert(iterator pos, const T& x)	序列	交换两个 vector 的内容。`在`pos`之前插入`.
template <class InputIterator> void insert(iterator pos, InputIterator f, InputIterator l) [1]	序列	x`插入范围`pos`之前插入`.
void insert(iterator pos, size_type n, const T& x)	序列	交换两个 vector 的内容。`n`的`在`pos`之前插入`.
`[first, last)`	序列	iterator erase(iterator pos)`之前插入`.
`删除位置为`	序列	iterator erase(iterator first, iterator last)`插入范围`
`删除范围`	序列	void clear()
`删除所有元素。`	序列	void resize(n, t = T())`n`.
bool operator==(const vector&, const vector&)	在末尾插入或删除元素，使大小变为	前向容器
bool operator<(const vector&, const vector&)	在末尾插入或删除元素，使大小变为	测试两个 vector 是否相等。这是一个全局函数，而不是成员函数。

词典排序比较。这是一个全局函数，而不是成员函数。

新成员vector.

成员	描述
`size_type capacity() const`	这些成员没有在随机访问容器和后插入序列要求中定义，而是特定于`为其分配了内存的元素数量。`capacity()`始终大于或等于`. [2] [3]
`size()`	。`n`void reserve(size_type n)`为其分配了内存的元素数量。`如果`为其分配了内存的元素数量。`小于或等于`n`，则此调用没有效果。否则，它将请求分配更多内存。如果请求成功，则`为其分配了内存的元素数量。`大于或等于`始终大于或等于`；否则，

保持不变。在这两种情况下，

都保持不变。 [2] [4]备注.

[1] 此成员函数依赖于成员模板函数，目前（1998 年初）并非所有编译器都支持。如果您的编译器支持成员模板，则可以使用任何类型的输入迭代器调用此函数。但是，如果您的编译器尚不支持成员模板，则参数必须是const value_type*类型。始终大于或等于[2] 如果插入的元素超过为其分配了内存的元素数量。capacity() - size()

，则将自动重新分配内存。重新分配不会更改为其分配了内存的元素数量。, vector，也不会更改 vector 中任何元素的值。但是，它会增加为其分配了内存的元素数量。，并且会使 [5] 指向 vector 的任何迭代器失效。

[4] [3] 当需要增加时，通常会将其增加两倍。重要的是，增长量与当前成比例，而不是一个固定的常数：在前一种情况下，将一系列元素插入 vector 是一个线性时间操作，而在后一种情况下，它是一个二次时间操作。Reserve()vector手动导致重新分配。使用成比例，而不是一个固定的常数：在前一种情况下，将一系列元素插入 vector 是一个线性时间操作，而在后一种情况下，它是一个二次时间操作。reserve()

的主要原因是效率：如果您知道 vector 最终必须增长到的容量，那么通常一次性分配该内存比依赖于自动重新分配方案更有效。使用成比例，而不是一个固定的常数：在前一种情况下，将一系列元素插入 vector 是一个线性时间操作，而在后一种情况下，它是一个二次时间操作。的另一个原因是您可以控制迭代器的失效。 [5]

[5] 当 vector 的内存重新分配时，其迭代器将失效。此外，在 vector 中间插入或删除元素会使指向插入或删除点之后元素的所有迭代器失效。因此，如果您使用

预先分配 vector 将使用的所有内存，并且所有插入和删除都在 vector 的末尾，则可以防止 vector 的迭代器失效。

另请参见 deque，list，slist