concurrency, opérateur de l’espace de noms

operator||
operator&&

operator==
operator!=

operator<
operator<=

operator>
operator>=

operator||, opérateur

Crée une tâche qui s’effectue correctement quand l’une des tâches fournies en tant qu’arguments s’effectue correctement.

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);

Paramètres

ReturnType
Type de la tâche retournée.

Lhs
Première tâche à associer à la tâche obtenue.

rhs
Seconde tâche à associer à la tâche obtenue.

Valeur de retour

Tâche qui s’exécute correctement lorsque l’une des tâches d’entrée s’est terminée correctement. Si les tâches d’entrée sont de type T, le résultat de cette fonction sera task<std::vector<T>. Si les tâches d’entrée sont de type void, la tâche de sortie sera également task<void>.

Notes

Si les deux tâches sont annulées ou levées, la tâche retournée se termine dans l’état annulé et l’une des exceptions, le cas échéant, est levée lorsque vous appelez get() ou wait() sur cette tâche.

operator&&, opérateur

Crée une tâche qui s’achève correctement lorsque les deux tâches fournies en tant qu’arguments se terminent correctement.

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);

Paramètres

ReturnType
Type de la tâche retournée.

Lhs
Première tâche à associer à la tâche obtenue.

rhs
Seconde tâche à associer à la tâche obtenue.

Valeur de retour

Tâche qui s'effectue correctement lorsque les deux tâches d'entrée se sont correctement déroulées. Si les tâches d’entrée sont de type T, le résultat de cette fonction sera task<std::vector<T>>. Si les tâches d’entrée sont de type void, la tâche de sortie sera également task<void>.

Notes

Si l’une des tâches est annulée ou lève une exception, la tâche retournée se termine tôt, dans l’état annulé et l’exception, si elle se produit, est levée si vous appelez get() ou wait() sur cette tâche.

operator==, opérateur

Teste si l'objet concurrent_vector situé à gauche de l'opérateur est égal à l'objet concurrent_vector situé à droite.

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

Paramètres

T
Type de données des éléments stockés dans les vecteurs simultanés.

A1
Type d’allocateur du premier concurrent_vector objet.

A2
Type d’allocateur du deuxième concurrent_vector objet.

_Un
Objet de type concurrent_vector.

_B
Objet de type concurrent_vector.

Valeur de retour

true si le vecteur simultané situé à gauche de l’opérateur est égal au vecteur simultané situé à droite de l’opérateur ; sinon false.

Notes

Deux vecteurs simultanés sont égaux s’ils ont le même nombre d’éléments et que leurs éléments respectifs ont les mêmes valeurs. Sinon, elles sont inégales.

Cette méthode n’est pas sécurisée par rapport à d’autres méthodes susceptibles de modifier l’un des vecteurs simultanés _A ou _B.

operator !=, opérateur

Teste si l'objet concurrent_vector situé à gauche de l'opérateur n'est pas égal à l'objet concurrent_vector situé à droite.

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

Paramètres

T
Type de données des éléments stockés dans les vecteurs simultanés.

A1
Type d’allocateur du premier concurrent_vector objet.

A2
Type d’allocateur du deuxième concurrent_vector objet.

_Un
Objet de type concurrent_vector.

_B
Objet de type concurrent_vector.

Valeur de retour

true si les vecteurs simultanés ne sont pas égaux ; false si les vecteurs simultanés sont égaux.

Notes

Deux vecteurs simultanés sont égaux s’ils ont le même nombre d’éléments et que leurs éléments respectifs ont les mêmes valeurs. Sinon, elles sont inégales.

Cette méthode n’est pas sécurisée par rapport à d’autres méthodes susceptibles de modifier l’un des vecteurs simultanés _A ou _B.

operator<, opérateur

Teste si l'objet concurrent_vector situé à gauche de l'opérateur est inférieur à l'objet concurrent_vector situé à droite.

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

Paramètres

T
Type de données des éléments stockés dans les vecteurs simultanés.

A1
Type d’allocateur du premier concurrent_vector objet.

A2
Type d’allocateur du deuxième concurrent_vector objet.

_Un
Objet de type concurrent_vector.

_B
Objet de type concurrent_vector.

Valeur de retour

true si le vecteur simultané situé à gauche de l’opérateur est inférieur au vecteur simultané situé à droite de l’opérateur ; sinon false.

Notes

Le comportement de cet opérateur est identique à l’opérateur équivalent de la classe dans l’espace vectorstd de noms.

Cette méthode n’est pas sécurisée par rapport à d’autres méthodes susceptibles de modifier l’un des vecteurs simultanés _A ou _B.

operator<=, opérateur

Teste si l'objet concurrent_vector situé à gauche de l'opérateur est inférieur ou égal à l'objet concurrent_vector situé à droite.

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

Paramètres

T
Type de données des éléments stockés dans les vecteurs simultanés.

A1
Type d’allocateur du premier concurrent_vector objet.

A2
Type d’allocateur du deuxième concurrent_vector objet.

_Un
Objet de type concurrent_vector.

_B
Objet de type concurrent_vector.

Valeur de retour

true si le vecteur simultané situé à gauche de l’opérateur est inférieur ou égal au vecteur simultané situé à droite de l’opérateur ; sinon false.

Notes

Le comportement de cet opérateur est identique à l’opérateur équivalent de la classe dans l’espace vectorstd de noms.

Cette méthode n’est pas sécurisée par rapport à d’autres méthodes susceptibles de modifier l’un des vecteurs simultanés _A ou _B.

operator>, opérateur

Teste si l'objet concurrent_vector situé à gauche de l'opérateur est supérieur à l'objet concurrent_vector situé à droite.

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

Paramètres

T
Type de données des éléments stockés dans les vecteurs simultanés.

A1
Type d’allocateur du premier concurrent_vector objet.

A2
Type d’allocateur du deuxième concurrent_vector objet.

_Un
Objet de type concurrent_vector.

_B
Objet de type concurrent_vector.

Valeur de retour

true si le vecteur simultané situé à gauche de l’opérateur est supérieur au vecteur simultané situé à droite de l’opérateur ; sinon false.

Notes

Le comportement de cet opérateur est identique à l’opérateur équivalent de la classe dans l’espace vectorstd de noms.

Cette méthode n’est pas sécurisée par rapport à d’autres méthodes susceptibles de modifier l’un des vecteurs simultanés _A ou _B.

operator>=, opérateur

Teste si l'objet concurrent_vector situé à gauche de l'opérateur est supérieur ou égal à l'objet concurrent_vector situé à droite.

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

Paramètres

T
Type de données des éléments stockés dans les vecteurs simultanés.

A1
Type d’allocateur du premier concurrent_vector objet.

A2
Type d’allocateur du deuxième concurrent_vector objet.

_Un
Objet de type concurrent_vector.

_B
Objet de type concurrent_vector.

Valeur de retour

true si le vecteur simultané situé à gauche de l’opérateur est supérieur ou égal au vecteur simultané situé à droite de l’opérateur ; sinon false.

Notes

Le comportement de cet opérateur est identique à l’opérateur équivalent de la classe dans l’espace vectorstd de noms.

Cette méthode n’est pas sécurisée par rapport à d’autres méthodes susceptibles de modifier l’un des vecteurs simultanés _A ou _B.

Voir aussi

accès concurrentiel Namespace