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 对象。

另请参阅

并发命名空间
并行容器和对象