concurrency 命名空間運算子

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 的方法不一致。

另請參閱

concurrency 命名空間