并发命名空间运算符

  • 项目

operator||
operator&&

operator==
operator!=

operator<
operator<=

operator>
operator>=

operator|| 运算符

创建将在作为参数提供的任一任务成功完成时成功完成的任务。

template<typename ReturnType>
task<ReturnType> operator||(
    const task<ReturnType>& lhs,
    const task<ReturnType>& rhs);

template<typename ReturnType>
task<std::vector<ReturnType>> operator||(
    const task<std::vector<ReturnType>>& lhs,
    const task<ReturnType>& rhs);

template<typename ReturnType>
task<std::vector<ReturnType>> operator||(
    const task<ReturnType>& lhs,
    const task<std::vector<ReturnType>>& rhs);

inline task<void> operator||(
    const task<void>& lhs,
    const task<void>& rhs);

参数

ReturnType
已返回任务的类型。

lhs
要合并到结果任务的第一个任务。

rhs
要合并到结果任务的第二个任务。

返回值

在输入任务中任何一个成功完成时成功完成的任务。 如果输入任务的类型为 T，则此函数的输出将为 task<std::vector<T>。 如果输入任务的类型为 void，则输出任务也将是 task<void>。

注解

如果两个任务均被取消或引发异常，则返回的任务将在已取消状态下完成，并且当您对此任务调用 get() 或 wait() 时将引发一种异常（在遇到异常的情况下）。

operator&& 运算符

创建一个任务，在作为参数提供的两个任务成功完成后，此任务将成功完成。

template<typename ReturnType>
task<std::vector<ReturnType>>  operator&&(
    const task<ReturnType>& lhs,
    const task<ReturnType>& rhs);

template<typename ReturnType>
task<std::vector<ReturnType>>  operator&&(
    const task<std::vector<ReturnType>>& lhs,
    const task<ReturnType>& rhs);

template<typename ReturnType>
task<std::vector<ReturnType>>  operator&&(
    const task<ReturnType>& lhs,
    const task<std::vector<ReturnType>>& rhs);

template<typename ReturnType>
task<std::vector<ReturnType>>  operator&&(
    const task<std::vector<ReturnType>>& lhs,
    const task<std::vector<ReturnType>>& rhs);

inline task<void>  operator&&(
    const task<void>& lhs,
    const task<void>& rhs);

参数

ReturnType
已返回任务的类型。

lhs
要合并到结果任务的第一个任务。

rhs
要合并到结果任务的第二个任务。

返回值

将在两个输入任务成功完成后成功完成的任务。 如果输入任务的类型为 T，则此函数的输出将为 task<std::vector<T>>。 如果输入任务的类型为 void，则输出任务也将是 task<void>。

注解

如果其中一个任务被取消或引发异常，则返回的任务将提前完成（处于已取消状态），并且如果调用任务上的 get() 或 wait()，则会在遇到异常的情况下引发异常。

operator== 运算符

测试运算符左侧的 concurrent_vector 对象是否等于右侧的 concurrent_vector 对象。

template<typename T, class A1, class A2>
inline bool operator== (
    const concurrent_vector<T, A1>& _A,
    const concurrent_vector<T, A2>& _B);

参数

T
并发向量中存储的元素的数据类型。

A1
第一个 concurrent_vector 对象的分配器类型。

A2
第二个 concurrent_vector 对象的分配器类型。

_A
一个 concurrent_vector 类型的对象。

_B
一个 concurrent_vector 类型的对象。

返回值

如果运算符左侧的并发向量等于运算符右侧的并发向量，则为 true；否则为 false。

备注

如果两个并发向量的元素数目相同且对应元素具有相同的值，则两个并发向量相等。 否则，它们不相等。

对于可以修改并发向量 _A 或 _B 的其他方法，此方法不是并发安全的。

operator!= 运算符

测试运算符左侧的 concurrent_vector 对象是否不等于右侧的 concurrent_vector 对象。

template<typename T, class A1, class A2>
inline bool operator!= (
    const concurrent_vector<T, A1>& _A,
    const concurrent_vector<T, A2>& _B);

参数

T
并发向量中存储的元素的数据类型。

A1
第一个 concurrent_vector 对象的分配器类型。

A2
第二个 concurrent_vector 对象的分配器类型。

_A
一个 concurrent_vector 类型的对象。

_B
一个 concurrent_vector 类型的对象。

返回值

如果并发向量不相等，则为 true；如果并发向量相等，则为 false。

备注

如果两个并发向量的元素数目相同且对应元素具有相同的值，则两个并发向量相等。 否则，它们不相等。

对于可以修改并发向量 _A 或 _B 的其他方法，此方法不是并发安全的。

operator< 运算符

测试运算符左侧的 concurrent_vector 对象是否小于右侧的 concurrent_vector 对象。

template<typename T, class A1, class A2>
inline bool operator<(
    const concurrent_vector<T, A1>& _A,
    const concurrent_vector<T, A2>& _B);

参数

T
并发向量中存储的元素的数据类型。

A1
第一个 concurrent_vector 对象的分配器类型。

A2
第二个 concurrent_vector 对象的分配器类型。

_A
一个 concurrent_vector 类型的对象。

_B
一个 concurrent_vector 类型的对象。

返回值

如果运算符左侧的并发向量小于运算符右侧的并发向量，则为 true；否则为 false。

注解

此运算符的行为与 std 命名空间中 vector 类的等效运算符相同。

对于可以修改并发向量 _A 或 _B 的其他方法，此方法不是并发安全的。

operator<= 运算符

测试运算符左侧的 concurrent_vector 对象是否小于或等于右侧的 concurrent_vector 对象。

template<typename T, class A1, class A2>
inline bool operator<= (
    const concurrent_vector<T, A1>& _A,
    const concurrent_vector<T, A2>& _B);

参数

T
并发向量中存储的元素的数据类型。

A1
第一个 concurrent_vector 对象的分配器类型。

A2
第二个 concurrent_vector 对象的分配器类型。

_A
一个 concurrent_vector 类型的对象。

_B
一个 concurrent_vector 类型的对象。

返回值

如果运算符左侧的并发向量小于运算符右侧的并发向量，则为 true；否则为 false。

备注

此运算符的行为与 std 命名空间中 vector 类的等效运算符相同。

对于可以修改并发向量 _A 或 _B 的其他方法，此方法不是并发安全的。

operator> 运算符

测试运算符左侧的 concurrent_vector 对象是否大于右侧的 concurrent_vector 对象。

template<typename T, class A1, class A2>
inline bool operator>(
    const concurrent_vector<T, A1>& _A,
    const concurrent_vector<T, A2>& _B);

参数

T
并发向量中存储的元素的数据类型。

A1
第一个 concurrent_vector 对象的分配器类型。

A2
第二个 concurrent_vector 对象的分配器类型。

_A
一个 concurrent_vector 类型的对象。

_B
一个 concurrent_vector 类型的对象。

返回值

如果运算符左侧的并发向量大于运算符右侧的并发向量，则为 true；否则为 false。

备注

此运算符的行为与 std 命名空间中 vector 类的等效运算符相同。

对于可以修改并发向量 _A 或 _B 的其他方法，此方法不是并发安全的。

operator>= 运算符

测试运算符左侧的 concurrent_vector 对象是否大于或等于右侧的 concurrent_vector 对象。

template<typename T, class A1, class A2>
inline bool operator>= (
    const concurrent_vector<T, A1>& _A,
    const concurrent_vector<T, A2>& _B);

参数

T
并发向量中存储的元素的数据类型。

A1
第一个 concurrent_vector 对象的分配器类型。

A2
第二个 concurrent_vector 对象的分配器类型。

_A
一个 concurrent_vector 类型的对象。

_B
一个 concurrent_vector 类型的对象。

返回值

如果运算符左侧的并发向量大于运算符右侧的并发向量，则为 true；否则为 false。

备注

此运算符的行为与 std 命名空间中 vector 类的等效运算符相同。

对于可以修改并发向量 _A 或 _B 的其他方法，此方法不是并发安全的。

另请参阅

并发命名空间