concurrent_vector 类
concurrent_vector 类是允许对任意元素进行随机访问的序列容器类。 它支持并发安全追加、元素访问、迭代器访问和迭代器遍历操作。 在这里，并发安全意味着指针或迭代器始终有效。 它不保证元素初始化或特定的遍历顺序。
语法
template<typename T, class _Ax>
class concurrent_vector: protected details::_Allocator_base<T,
_Ax>,
private details::_Concurrent_vector_base_v4;
参数
T
要存储在向量中的元素的数据类型。
_Ax
一种表示存储的分配器对象的类型，该分配器对象封装有关并发向量的内存分配和解除分配的详细信息。 此参数为可选参数，默认值为 allocator<T>。
成员
公共 Typedef
| 名称 | 描述 |
|---|---|
allocator_type |
一种表示适用于并发向量的分配器类的类型。 |
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 |
一个类型，它表示存储在并发向量中的数据类型。 |
公共构造函数
| 名称 | 描述 |
|---|---|
| concurrent_vector | 已重载。 构造并发向量。 |
| ~concurrent_vector 析构函数 | 清除所有元素并销毁此并发向量。 |
公共方法
| 名称 | 描述 |
|---|---|
| assign | 已重载。 清除并发向量的元素，并为其分配 _Item 的 _N 个副本，或由迭代器范围 [ _Begin, _End) 指定的值。 此方法不是并发安全方法。 |
| at | 已重载。 提供对并发向量中给定索引处的元素的访问。 此方法是读取操作的并发安全方法，并且同时增加向量，前提是确保值 _Index 小于并发向量的大小。 |
| back | 已重载。 返回对并发向量中最后一个元素的引用或 const 引用。 如果并发向量为空，则返回值不确定。 此方法是并发安全的。 |
| begin | 已重载。 将 iterator 或 const_iterator 类型的迭代器返回到并发向量的开头。 此方法是并发安全的。 |
| 容量 | 返回无需分配更多内存的情况下并发向量可增长到的最大大小。 此方法是并发安全的。 |
| cbegin | 将 const_iterator 类型的迭代器返回到并发向量的开头。 此方法是并发安全的。 |
| cend | 将 const_iterator 类型的迭代器返回到并发向量的末尾。 此方法是并发安全的。 |
| clear | 清除并发向量中的所有元素。 此方法不是并发安全方法。 |
| crbegin | 将 const_reverse_iterator 类型的迭代器返回到并发向量的开头。 此方法是并发安全的。 |
| crend | 将 const_reverse_iterator 类型的迭代器返回到并发向量的末尾。 此方法是并发安全的。 |
| empty | 测试在调用此方法时并发向量是否为空。 此方法是并发安全的。 |
| end | 已重载。 将 iterator 或 const_iterator 类型的迭代器返回到并发向量的末尾。 此方法是并发安全的。 |
| front | 已重载。 返回对并发向量中第一个元素的引用或 const 引用。 如果并发向量为空，则返回值不确定。 此方法是并发安全的。 |
| get_allocator | 返回用于构造并发向量的分配器的副本。 此方法是并发安全的。 |
| grow_by | 已重载。 按 _Delta 元素增大此并发向量。 此方法是并发安全的。 |
| grow_to_at_least | 增大此并发向量，直到它至少有 _N 个元素。 此方法是并发安全的。 |
| max_size | 返回并发向量可以容纳的最大元素数。 此方法是并发安全的。 |
| push_back | 已重载。 将给定项追加到并发向量的末尾。 此方法是并发安全的。 |
| rbegin | 已重载。 将 reverse_iterator 或 const_reverse_iterator 类型的迭代器返回到并发向量的开头。 此方法是并发安全的。 |
| rend | 已重载。 将 reverse_iterator 或 const_reverse_iterator 类型的迭代器返回到并发向量的末尾。 此方法是并发安全的。 |
| reserve | 分配足够的空间，以便将并发向量增大为大小 _N，而无需稍后分配更多内存。 此方法不是并发安全方法。 |
| resize | 已重载。 根据需要删除或添加元素将并发向量的大小更改为请求的大小。 此方法不是并发安全方法。 |
| shrink_to_fit | 压缩并发向量的内部表示形式，以减少碎片并优化内存使用情况。 此方法不是并发安全方法。 |
| size | 返回并发向量中的元素数量。 此方法是并发安全的。 |
| swap | 交换两个并发向量中的内容。 此方法不是并发安全方法。 |
公共运算符
| “属性” | 描述 |
|---|---|
| operator[] | 已重载。 提供对并发向量中给定索引处的元素的访问。 此方法是读取操作的并发安全方法，并且同时增加向量，前提是确保值 _Index 小于并发向量的大小。 |
| operator= | 已重载。 将另一 concurrent_vector 对象的内容分配给此对象。 此方法不是并发安全方法。 |
注解
有关 concurrent_vector 类的详细信息，请参阅并行容器和对象。
继承层次结构
_Concurrent_vector_base_v4
_Allocator_base
concurrent_vector
要求
标头：concurrent_vector.h
命名空间： 并发
assign
清除并发向量的元素，并为其分配 _Item 的 _N 个副本，或由迭代器范围 [ _Begin, _End) 指定的值。 此方法不是并发安全方法。
void assign(
size_type _N,
const_reference _Item);
template<class _InputIterator>
void assign(_InputIterator _Begin,
_InputIterator _End);
参数
_InputIterator
指定的迭代器的类型。
_N
要复制到并发向量中的项数。
_Item
对用于填充并发向量的值的引用。
_Begin
指向源范围的第一个元素的迭代器。
_End
指向源范围最后一个元素的下一个位置的迭代器。
备注
assign 不是并发安全的。 调用此方法时，必须确保没有其他线程在并发向量上调用方法。
at
提供对并发向量中给定索引处的元素的访问。 此方法是读取操作的并发安全方法，并且同时增加向量，前提是确保值 _Index 小于并发向量的大小。
reference at(size_type _Index);
const_reference at(size_type _Index) const;
参数
_Index
要检索的元素的索引。
返回值
对给定索引处的项的引用。
备注
返回非 const 引用的函数 at 的版本不可用于并发地写入来自不同线程的元素。 应使用不同的同步对象将并发读取和写入操作同步到同一数据元素。
如果 _Index 大于或等于并发向量的大小，则该方法引发 out_of_range，如果索引用于向量的损坏部分，则引发 range_error。 有关向量如何损坏的详细信息，请参阅并行容器和对象。
返回
返回对并发向量中最后一个元素的引用或 const 引用。 如果并发向量为空，则返回值不确定。 此方法是并发安全的。
reference back();
const_reference back() const;
返回值
对并发向量中最后一个元素的引用或 const 引用。
begin
将 iterator 或 const_iterator 类型的迭代器返回到并发向量的开头。 此方法是并发安全的。
iterator begin();
const_iterator begin() const;
返回值
指向并发向量开头的 iterator 或 const_iterator 类型的迭代器。
容量
返回无需分配更多内存的情况下并发向量可增长到的最大大小。 此方法是并发安全的。
size_type capacity() const;
返回值
无需分配更多内存的情况下并发向量可增长到的最大大小。
备注
与 C++ 标准库 vector 不同，concurrent_vector 对象在分配更多内存时不会移动现有元素。
cbegin
将 const_iterator 类型的迭代器返回到并发向量的开头。 此方法是并发安全的。
const_iterator cbegin() const;
返回值
指向并发向量开头的 const_iterator 类型的迭代器。
cend
将 const_iterator 类型的迭代器返回到并发向量的末尾。 此方法是并发安全的。
const_iterator cend() const;
返回值
指向并发向量末尾的 const_iterator 类型的迭代器。
clear
清除并发向量中的所有元素。 此方法不是并发安全方法。
void clear();
备注
clear 不是并发安全的。 调用此方法时，必须确保没有其他线程在并发向量上调用方法。 clear 不释放内部数组。 若要释放内部数组，请在 clear 之后调用函数 shrink_to_fit。
concurrent_vector
构造并发向量。
explicit concurrent_vector(
const allocator_type& _Al = allocator_type());
concurrent_vector(
const concurrent_vector& _Vector);
template<class M>
concurrent_vector(
const concurrent_vector<T,
M>& _Vector,
const allocator_type& _Al = allocator_type());
concurrent_vector(
concurrent_vector&& _Vector);
explicit concurrent_vector(
size_type _N);
concurrent_vector(
size_type _N,
const_reference _Item,
const allocator_type& _Al = allocator_type());
template<class _InputIterator>
concurrent_vector(_InputIterator _Begin,
_InputIterator _End,
const allocator_type& _Al = allocator_type());
参数
M
源向量的分配器类型。
_InputIterator
输入迭代器的类型。
_Al
要用于此对象的分配器类。
_Vector
要从中复制或移动元素的源 concurrent_vector 对象。
_N
concurrent_vector 对象的初始容量。
_Item
构造的对象中的元素值。
_Begin
要复制的元素范围内的第一个元素的位置。
_End
要复制的元素范围外的第一个元素的位置。
注解
所有构造函数都存储分配器对象 _Al 并初始化此向量。
第一个构造函数指定一个空的初始向量，并显式指定要使用的分配器类型 。
第二个和第三个构造函数指定并发向量 _Vector 的副本。
第四个构造函数指定并发向量 _Vector 的移动。
第五个构造函数指定类 T 默认值的指定数量 (_N) 元素的重复。
第六个构造函数指定值 _Item 的 (_N) 元素的重复。
最后一个构造函数指定迭代器范围 [_Begin, _End) 提供的值。
~concurrent_vector
清除所有元素并销毁此并发向量。
~concurrent_vector();
crbegin
将 const_reverse_iterator 类型的迭代器返回到并发向量的开头。 此方法是并发安全的。
const_reverse_iterator crbegin() const;
返回值
指向并发向量开头的 const_reverse_iterator 类型的迭代器。
crend
将 const_reverse_iterator 类型的迭代器返回到并发向量的末尾。 此方法是并发安全的。
const_reverse_iterator crend() const;
返回值
指向并发向量末尾的 const_reverse_iterator 类型的迭代器。
empty
测试在调用此方法时并发向量是否为空。 此方法是并发安全的。
bool empty() const;
返回值
如果在调用函数时向量为空，则为 true，否则为 false。
end
将 iterator 或 const_iterator 类型的迭代器返回到并发向量的末尾。 此方法是并发安全的。
iterator end();
const_iterator end() const;
返回值
指向并发向量末尾的 iterator 或 const_iterator 类型的迭代器。
front
返回对并发向量中第一个元素的引用或 const 引用。 如果并发向量为空，则返回值不确定。 此方法是并发安全的。
reference front();
const_reference front() const;
返回值
对并发向量中第一个元素的引用或 const 引用。
get_allocator
返回用于构造并发向量的分配器的副本。 此方法是并发安全的。
allocator_type get_allocator() const;
返回值
用于构造 concurrent_vector 对象的分配器的副本。
grow_by
按 _Delta 元素增大此并发向量。 此方法是并发安全的。
iterator grow_by(
size_type _Delta);
iterator grow_by(
size_type _Delta,
const_reference _Item);
参数
_Delta
要追加到对象的元素数。
_Item
用于初始化新元素的值。
返回值
指向追加的第一个项的迭代器。
备注
如果未指定 _Item，则默认构造新元素。
grow_to_at_least
增大此并发向量，直到它至少有 _N 个元素。 此方法是并发安全的。
iterator grow_to_at_least(size_type _N);
参数
_N
concurrent_vector 对象的新最小大小。
返回值
一个迭代器，它指向追加序列的开头，如果没有追加元素，则指向索引 _N 处的元素。
max_size
返回并发向量可以容纳的最大元素数。 此方法是并发安全的。
size_type max_size() const;
返回值
concurrent_vector 对象可以容纳的最大元素数。
operator=
将另一 concurrent_vector 对象的内容分配给此对象。 此方法不是并发安全方法。
concurrent_vector& operator= (
const concurrent_vector& _Vector);
template<class M>
concurrent_vector& operator= (
const concurrent_vector<T, M>& _Vector);
concurrent_vector& operator= (
concurrent_vector&& _Vector);
参数
M
源向量的分配器类型。
_Vector
源 concurrent_vector 对象。
返回值
对此 concurrent_vector 对象的引用。
operator[]
提供对并发向量中给定索引处的元素的访问。 此方法是读取操作的并发安全方法，并且同时增加向量，前提是确保值 _Index 小于并发向量的大小。
reference operator[](size_type _index);
const_reference operator[](size_type _index) const;
参数
_Index
要检索的元素的索引。
返回值
对给定索引处的项的引用。
备注
返回非 const 引用的 operator [] 的版本不可用于并发地写入来自不同线程的元素。 应使用不同的同步对象将并发读取和写入操作同步到同一数据元素。
不执行边界检查以确保 _Index 是并发向量的有效索引。
push_back
将给定项追加到并发向量的末尾。 此方法是并发安全的。
iterator push_back(const_reference _Item);
iterator push_back(T&& _Item);
参数
_Item
要追加的值。
返回值
指向追加项的迭代器。
rbegin
将 reverse_iterator 或 const_reverse_iterator 类型的迭代器返回到并发向量的开头。 此方法是并发安全的。
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
返回值
指向并发向量开头的 reverse_iterator 或 const_reverse_iterator 类型的迭代器。
rend
将 reverse_iterator 或 const_reverse_iterator 类型的迭代器返回到并发向量的末尾。 此方法是并发安全的。
reverse_iterator rend();
const_reverse_iterator rend() const;
返回值
指向并发向量末尾的 reverse_iterator 或 const_reverse_iterator 类型的迭代器。
reserve
分配足够的空间，以便将并发向量增大为大小 _N，而无需稍后分配更多内存。 此方法不是并发安全方法。
void reserve(size_type _N);
参数
_N
要为其保留空间的元素数。
备注
reserve 不是并发安全的。 调用此方法时，必须确保没有其他线程在并发向量上调用方法。 方法返回后并发向量的容量可能大于请求的预留。
调整大小
根据需要删除或添加元素将并发向量的大小更改为请求的大小。 此方法不是并发安全方法。
void resize(
size_type _N);
void resize(
size_type _N,
const T& val);
参数
_N
并发向量的新大小。
val
新的大小大于原始大小时添加至向量的新元素的值。 如果省略该值，则为新对象分配其类型的默认值。
备注
如果容器的大小小于请求的大小，则会在向量中添加元素，直到该容器达到请求的大小。 如果容器的大小大于请求的大小，最接近容器末尾的元素将被删除，直到该容器达到大小 _N。 如果容器的当前大小与请求的大小相同，则不采取任何操作。
resize 不是并发安全的。 调用此方法时，必须确保没有其他线程在并发向量上调用方法。
shrink_to_fit
压缩并发向量的内部表示形式，以减少碎片并优化内存使用情况。 此方法不是并发安全方法。
void shrink_to_fit();
备注
此方法将在内部重新分配内存移动元素，使所有迭代器无效。 shrink_to_fit 不是并发安全的。 调用此函数时，必须确保没有其他线程在并发向量上调用方法。
大小
返回并发向量中的元素数量。 此方法是并发安全的。
size_type size() const;
返回值
此 concurrent_vector 对象中的元素数。
备注
返回的大小保证包括调用函数 push_back 追加的所有元素，或者增加在调用此方法之前已完成的操作。 但是，它也可能包括通过并发调用任何增长方法分配但仍在构建中的元素。
swap
交换两个并发向量中的内容。 此方法不是并发安全方法。
void swap(concurrent_vector& _Vector);
参数
_Vector
要与其交换内容的 concurrent_vector 对象。